Los componentes de partícula describen cada partícula por separado: cómo empieza, cómo se mueve, qué aspecto tiene y cuándo desaparece. Van en el bloque components de un archivo de partículas, junto a los componentes de emisor que las generan.
¿Eres nuevo con las partículas? Tu primera partícula crea un destello de rubí desde cero y usa la mayoría de estos componentes.
Lo que necesita toda partícula
En la práctica, todos los efectos necesitan particle_lifetime_expression (si no, las partículas nunca desaparecen) y particle_appearance_billboard (si no, no se ve nada). Todo lo demás es opcional y se puede combinar libremente.
Los campos numéricos aceptan un número normal o un texto de Molang. Dentro puedes usar variable.particle_age, variable.particle_lifetime y de variable.particle_random_1 a _4 para darle a cada partícula su propia personalidad.
Estado inicial
Estos se fijan una sola vez, cuando nace la partícula.
| Componente | Qué hace | Campos clave |
|---|---|---|
minecraft:particle_initial_speed | A qué velocidad empieza a moverse la partícula | Un número (bloques por segundo, en la dirección que da la forma del emisor), o una velocidad [x, y, z] |
minecraft:particle_initial_spin | El ángulo inicial de la imagen y lo rápido que gira | rotation: grados (por defecto 0). rotation_rate: grados por segundo (por defecto 0) |
minecraft:particle_initialization | Ejecuta tu propio Molang para cada partícula, para asignar variables que leen otros campos | per_update_expression: se ejecuta en cada actualización. per_render_expression: se ejecuta cada vez que se dibuja |
Velocidad
"minecraft:particle_initial_speed": "math.random(1, 2)"Con un número, la partícula sale volando en la dirección que le dio la forma del emisor. Con tres números, defines tú la velocidad, por ejemplo [0, 2, 0] para ir justo hacia arriba. Si omites el componente, las partículas empiezan quietas.
Giro
"minecraft:particle_initial_spin": {
"rotation": "math.random(0, 360)",
"rotation_rate": "math.random(-90, 90)"
}El giro hace rotar la imagen plana alrededor de su centro, como una rueda. Un ángulo inicial aleatorio es la forma más fácil de que un montón de partículas no parezcan copias.
Tus propias variables
"minecraft:particle_initialization": {
"per_render_expression": "variable.twinkle = math.sin(variable.particle_age * 720) * 0.5 + 0.5;"
}Ahora variable.twinkle oscila entre 0 y 1 dos veces por segundo, y puedes usarla para el tamaño o el color. Para un valor que siga una forma a lo largo de toda la vida, una curva suele ser más sencilla.
Movimiento
Estos mueven la partícula en cada fotograma, después de que nazca.
| Componente | Qué hace | Campos clave |
|---|---|---|
minecraft:particle_motion_dynamic | Movimiento real con fuerzas: gravedad, viento, resistencia del aire, aceleración del giro | linear_acceleration, linear_drag_coefficient, rotation_acceleration, rotation_drag_coefficient |
minecraft:particle_motion_parametric | Tú fijas la posición exacta en cada fotograma con Molang, sin tener en cuenta las fuerzas | relative_position, direction, rotation |
minecraft:particle_motion_collision | Permite que las partículas choquen con los bloques: rebotar, deslizarse, pararse o desaparecer | enabled, collision_radius, coefficient_of_restitution, collision_drag, expire_on_contact, events |
Dinámico
"minecraft:particle_motion_dynamic": {
"linear_acceleration": [0, -9.8, 0],
"linear_drag_coefficient": 0.5,
"rotation_acceleration": 0,
"rotation_drag_coefficient": 0
}| Campo | Qué hace |
|---|---|
linear_acceleration | Un empuje cada segundo, como [x, y, z] en bloques por segundo al cuadrado. [0, -9.8, 0] se siente como una caída. Una y positiva hace que flote hacia arriba como el humo |
linear_drag_coefficient | Resistencia del aire. Cuanto más rápido va la partícula, más se frena. 0 significa ninguna |
rotation_acceleration | Hace que el giro se acelere (o se frene con un valor negativo), en grados por segundo al cuadrado |
rotation_drag_coefficient | Frena el giro, para que una partícula que gira acabe parándose |
El movimiento dinámico actúa sobre la velocidad de la partícula, así que se combina con particle_initial_speed: empieza rápido y luego deja que la gravedad y la resistencia hagan el resto.
Paramétrico
"minecraft:particle_motion_parametric": {
"relative_position": [
"math.cos(variable.particle_age * 360) * 0.8",
"variable.particle_age",
"math.sin(variable.particle_age * 360) * 0.8"
]
}Aquí te saltas la física y simplemente dices dónde está la partícula, medido desde el emisor. Este ejemplo da una vuelta por segundo mientras sube un bloque por segundo: una espiral de rubí. direction y rotation se pueden definir de la misma forma.
El paramétrico necesita un emisor normal
El movimiento paramétrico no funciona con partículas generadas por emitter_rate_manual. En efectos pegados a una criatura, solo funciona cuando el emisor usa el espacio local para su posición.
Colisión
"minecraft:particle_motion_collision": {
"collision_radius": 0.1,
"coefficient_of_restitution": 0.4,
"collision_drag": 2,
"events": { "event": "pop", "min_speed": 2 }
}Sin este componente, las partículas atraviesan los bloques.
| Campo | Qué hace |
|---|---|
enabled | Activa o desactiva la colisión. Puede ser Molang, que se comprueba en cada fotograma. Activado por defecto |
collision_radius | Lo grande que es la partícula a la hora de chocar con bloques. Tiene que ser medio bloque o menos. Ajústalo más o menos al tamaño del cartel |
coefficient_of_restitution | Lo que rebota. 0 se para en seco, 1 rebota hasta la misma altura, y los valores intermedios pierden algo de altura en cada rebote |
collision_drag | Frena la partícula mientras toca una superficie, en bloques por segundo. Hace que se deslice hasta pararse |
expire_on_contact | true elimina la partícula en cuanto toca un bloque. Va bien para las gotas de lluvia |
events | Lanza uno de tus eventos cuando choca con algo, por ejemplo una salpicadura. Un objeto de evento o una lista. min_speed (al menos 2 bloques por segundo) ignora los toques suaves |
La colisión cuesta rendimiento
Comprobar los bloques para cada partícula le da trabajo al juego. Añade colisión solo donde se note la diferencia, y mantén bajo max_particles en esos efectos.
Aspecto
Estos deciden qué aspecto tiene la partícula en pantalla.
| Componente | Qué hace | Campos clave |
|---|---|---|
minecraft:particle_appearance_billboard | Dibuja la partícula como una imagen plana y decide su tamaño, hacia dónde mira y qué parte de la textura muestra | size, facing_camera_mode, direction, uv |
minecraft:particle_appearance_tinting | Colorea la imagen, con un solo color o con un degradado a lo largo del tiempo | color |
minecraft:particle_appearance_lighting | Hace que la partícula se vea más oscura en sitios oscuros y más clara con luz, como los bloques | ninguno: escribe {} |
Cartel (billboard)
"minecraft:particle_appearance_billboard": {
"size": [0.1, 0.1],
"facing_camera_mode": "lookat_xyz",
"uv": {
"texture_width": 32,
"texture_height": 8,
"uv": [0, 0],
"uv_size": [8, 8]
}
}size es [width, height] y se comprueba en cada fotograma, así que aquí puedes usar Molang para que la partícula crezca o encoja. Cada valor se mide desde el centro, así que 0.5 da un cuadrado de un bloque de ancho.
facing_camera_mode decide hacia dónde apunta la imagen plana:
| Modo | La imagen |
|---|---|
lookat_xyz | Siempre mira a la cámara, pero se mantiene derecha. La opción habitual |
rotate_xyz | Queda plana contra la pantalla y gira con la cámara |
lookat_y / rotate_y | Mira a la cámara pero solo gira a izquierda y derecha, como un recortable de pie en el suelo |
lookat_direction | Mira a la cámara mientras se alinea con la dirección de la partícula. Va bien para estelas |
direction_x / direction_y / direction_z | Apunta el lado x, el lado y o la cara de la imagen en la dirección de la partícula |
emitter_transform_xy / _xz / _yz | Queda plana en uno de los planos del emisor. _xz crea una calcomanía plana en el suelo |
Los modos de dirección necesitan saber hacia dónde apunta la partícula. Eso se define con direction:
"direction": {
"mode": "derive_from_velocity",
"min_speed_threshold": 0.01
}derive_from_velocity usa la dirección en la que se mueve la partícula, pero solo mientras va más rápido que min_speed_threshold. Usa "mode": "custom_direction" con "custom_direction": [x, y, z] para fijarla tú.
uv elige qué parte de la textura se muestra. texture_width y texture_height son el tamaño de tu PNG en píxeles; después, uv es la esquina superior izquierda y uv_size el ancho y el alto de la parte que quieres. El ejemplo de arriba muestra el primer fotograma de 8x8 de una tira de 32x8.
Animación tipo flipbook
Pon varios fotogramas uno al lado de otro y el cartel puede reproducirlos como un flipbook. Cambia uv y uv_size por flipbook:
"uv": {
"texture_width": 32,
"texture_height": 8,
"flipbook": {
"base_UV": [0, 0],
"size_UV": [8, 8],
"step_UV": [8, 0],
"max_frame": 4,
"stretch_to_lifetime": true,
"loop": false
}
}| Campo | Qué hace |
|---|---|
base_UV | Esquina superior izquierda del primer fotograma |
size_UV | Ancho y alto de un fotograma |
step_UV | Cuánto avanzar para el siguiente fotograma. [8, 0] avanza hacia la derecha |
max_frame | Cuántos fotogramas hay (el primero es el fotograma 1) |
frames_per_second | Velocidad de reproducción |
stretch_to_lifetime | true ignora la velocidad y reproduce todos los fotogramas exactamente una vez a lo largo de la vida de la partícula |
loop | true vuelve a empezar desde el primer fotograma después del último |
Un destello de rubí de 4 fotogramas que se abre, brilla y se vuelve a cerrar parece mucho más vivo que una sola imagen.
Tintado
"minecraft:particle_appearance_tinting": {
"color": [1, 0.15, 0.3, 1]
}El color multiplica la textura, así que dibuja las texturas de partículas en blanco o gris y deja que el tintado ponga el color. Puedes escribir un color de cualquiera de estas formas:
| Forma | Ejemplo |
|---|---|
[r, g, b] o [r, g, b, a], cada uno de 0 a 1 | [1, 0.15, 0.3, 1] |
"#RRGGBB" | "#FF2650" |
"#AARRGGBB" (primero el alfa) | "#80FF2650" es semitransparente |
| Molang en cada hueco | ["variable.tint.r", "variable.tint.g", "variable.tint.b", 1] |
Para cambiar de color con el tiempo, usa un degradado. Los colores se reparten de forma uniforme, e interpolant elige en qué punto del degradado está la partícula en cada momento:
"minecraft:particle_appearance_tinting": {
"color": {
"gradient": {
"0.0": "#FFFFFFFF",
"0.3": "#FFFF2650",
"1.0": "#00600018"
},
"interpolant": "variable.particle_age / variable.particle_lifetime"
}
}Escrito como un objeto así, cada color se coloca en el punto que indicas. Una lista normal los reparte de forma uniforme de 0 a 1. Este destello parpadea en blanco, se vuelve rojo rubí enseguida y luego se desvanece poco a poco.
El alfa necesita el material adecuado
Los colores semitransparentes solo se ven con el material particles_blend o particles_add. Con particles_alpha, un píxel se muestra entero o no se muestra.
Iluminación
"minecraft:particle_appearance_lighting": {}Con esto, las partículas se ven más oscuras en las cuevas y de noche, así encajan con el mundo. No lo pongas en cosas que deban brillar en la oscuridad: magia, fuego o nuestro destello de rubí.
Duración
Estos deciden cuándo desaparece una partícula.
| Componente | Qué hace | Campos clave |
|---|---|---|
minecraft:particle_lifetime_expression | La duración principal: un tiempo fijo o una prueba de Molang que se comprueba en cada fotograma | max_lifetime, expiration_expression |
minecraft:particle_lifetime_events | Lanza tus eventos en momentos concretos de la vida de cada partícula | creation_event, expiration_event, timeline |
minecraft:particle_kill_plane | Elimina las partículas que cruzan una superficie plana invisible | [A, B, C, D] |
minecraft:particle_expire_if_in_blocks | Elimina las partículas que están dentro de alguno de los bloques de la lista | Una lista de nombres de bloques |
minecraft:particle_expire_if_not_in_blocks | Elimina las partículas que salen de los bloques de la lista | Una lista de nombres de bloques |
Expresión de duración
"minecraft:particle_lifetime_expression": {
"max_lifetime": "math.random(0.8, 1.5)"
}max_lifetimees la vida en segundos, elegida una vez cuando nace la partícula.expiration_expressionse comprueba en cada fotograma. Cuando no vale 0, la partícula desaparece. Por ejemplo,"variable.particle_age > 1 && query.is_in_water"podría terminarla antes de tiempo.
Puedes usar los dos a la vez: la partícula desaparece con lo que ocurra primero.
Eventos de duración
"minecraft:particle_lifetime_events": {
"creation_event": "flash",
"expiration_event": "pop",
"timeline": {
"0.25": "twinkle"
}
}Los nombres apuntan al bloque events del mismo archivo, y cada campo acepta un nombre o una lista. A diferencia de la versión del emisor, estos se lanzan para cada partícula por separado, así que una ráfaga de 12 destellos lanza pop 12 veces. Mira eventos para saber qué puede hacer un evento.
Plano de eliminación
"minecraft:particle_kill_plane": [0, 1, 0, 0.5]Los cuatro números describen una superficie plana a la manera matemática: todos los puntos donde A*x + B*y + C*z + D = 0, medidos desde el emisor pero alineados con el mundo. Las partículas que la cruzan desaparecen. [0, 1, 0, 0.5] es un suelo medio bloque por debajo del emisor. Es una forma barata de detener partículas que caen sin usar colisión.
Dentro y fuera de bloques
"minecraft:particle_expire_if_not_in_blocks": [
"minecraft:water",
"minecraft:flowing_water",
"minecraft:bubble_column"
]Así es como las burbujas explotan al llegar a la superficie: solo viven mientras están dentro del agua. Usa particle_expire_if_in_blocks para lo contrario, por ejemplo polvo que desaparece en cuanto entra flotando en el agua. Los dos funcionan junto con particle_lifetime_expression.
Una partícula completa
Los cuatro grupos juntos. Esta es la parte de partícula de un fragmento de rubí que cae, rebota y se desvanece:
"minecraft:particle_initial_speed": "math.random(2, 3)",
"minecraft:particle_initial_spin": {
"rotation": "math.random(0, 360)",
"rotation_rate": 180
},
"minecraft:particle_motion_dynamic": {
"linear_acceleration": [0, -9.8, 0],
"rotation_drag_coefficient": 1
},
"minecraft:particle_motion_collision": {
"collision_radius": 0.05,
"coefficient_of_restitution": 0.3,
"collision_drag": 4
},
"minecraft:particle_appearance_billboard": {
"size": [0.06, 0.06],
"facing_camera_mode": "lookat_xyz",
"uv": {
"texture_width": 8,
"texture_height": 8,
"uv": [0, 0],
"uv_size": [8, 8]
}
},
"minecraft:particle_appearance_tinting": {
"color": "#FFE0204A"
},
"minecraft:particle_appearance_lighting": {},
"minecraft:particle_lifetime_expression": {
"max_lifetime": 2
}Dale un emisor de Componentes de emisor, por ejemplo una ráfaga de 8 desde una esfera pequeña, y tendrás un efecto genial para cuando se rompe un bloque.