Composants de particule

Les composants de particule décrivent chaque particule individuelle : comment elle démarre, comment elle bouge, à quoi elle ressemble et quand elle disparaît. Ils se trouvent dans le bloc components d'un fichier de particule, à côté des composants d'émetteur qui les font apparaître.

Tu débutes avec les particules ? Ta première particule construit une étincelle de rubis à partir de zéro et utilise la plupart de ces composants.

Les champs numériques acceptent un simple nombre ou une chaîne Molang. À l'intérieur, tu peux utiliser variable.particle_age, variable.particle_lifetime et variable.particle_random_1 à _4 pour donner à chaque particule sa propre personnalité.

État initial

Ces composants sont appliqués une seule fois, à la naissance de la particule.

La vitesse

"minecraft:particle_initial_speed": "math.random(1, 2)"

Avec un seul nombre, la particule vole dans la direction que lui a donnée la forme de l'émetteur. Avec trois nombres, tu définis toi-même la vélocité, par exemple [0, 2, 0] pour monter tout droit. Sans ce composant, les particules démarrent immobiles.

La rotation

"minecraft:particle_initial_spin": {
  "rotation": "math.random(0, 360)",
  "rotation_rate": "math.random(-90, 90)"
}

La rotation fait tourner l'image plate autour de son centre, comme une roue. Un angle de départ aléatoire est le moyen le plus simple d'éviter qu'une foule de particules ait l'air d'une série de copies.

Tes propres variables

"minecraft:particle_initialization": {
  "per_render_expression": "variable.twinkle = math.sin(variable.particle_age * 720) * 0.5 + 0.5;"
}

Maintenant, variable.twinkle oscille entre 0 et 1 deux fois par seconde, et tu peux t'en servir pour la taille ou la couleur. Pour une valeur qui suit une forme sur toute la durée de vie, une courbe est souvent plus simple.

Mouvement

Ces composants font bouger la particule à chaque image, après sa naissance.

Dynamique

"minecraft:particle_motion_dynamic": {
  "linear_acceleration": [0, -9.8, 0],
  "linear_drag_coefficient": 0.5,
  "rotation_acceleration": 0,
  "rotation_drag_coefficient": 0
}

Le mouvement dynamique agit sur la vitesse de la particule, il se combine donc avec particle_initial_speed : démarre vite, puis laisse la gravité et la résistance prendre le relais.

Paramétrique

"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"
  ]
}

Ici, tu laisses tomber la physique et tu dis simplement où se trouve la particule, par rapport à l'émetteur. Cet exemple fait un tour par seconde tout en montant d'un bloc par seconde : une spirale de rubis. direction et rotation se définissent de la même façon.

Collision

"minecraft:particle_motion_collision": {
  "collision_radius": 0.1,
  "coefficient_of_restitution": 0.4,
  "collision_drag": 2,
  "events": { "event": "pop", "min_speed": 2 }
}

Sans ce composant, les particules traversent les blocs.

Apparence

Ces composants décident de l'apparence de la particule à l'écran.

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 vaut [width, height] et est vérifié à chaque image, donc du Molang ici peut faire grandir ou rétrécir la particule. Chaque valeur se mesure depuis le centre, donc 0.5 donne un carré d'un bloc de large.

facing_camera_mode décide de l'orientation de l'image plate :

Les modes de direction ont besoin de savoir dans quelle direction pointe la particule. Définis-la avec direction :

"direction": {
  "mode": "derive_from_velocity",
  "min_speed_threshold": 0.01
}

derive_from_velocity utilise le sens de déplacement de la particule, mais seulement tant qu'elle va plus vite que min_speed_threshold. Utilise "mode": "custom_direction" avec "custom_direction": [x, y, z] pour la définir toi-même.

uv choisit la partie de la texture à afficher. texture_width et texture_height sont la taille de ton PNG en pixels, puis uv est le coin supérieur gauche et uv_size la largeur et la hauteur de la partie voulue. L'exemple ci-dessus affiche la première image de 8x8 d'une bande de 32x8.

Animation en flipbook

Place plusieurs images côte à côte et le billboard peut les jouer comme un folioscope. Remplace uv et uv_size par 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
  }
}

Une étincelle de rubis en 4 images qui s'ouvre, brille et se referme paraît bien plus vivante qu'une seule image.

Teinte

"minecraft:particle_appearance_tinting": {
  "color": [1, 0.15, 0.3, 1]
}

La couleur multiplie la texture, alors dessine tes textures de particules en blanc ou en gris et laisse la teinte ajouter la couleur. Tu peux écrire une couleur de plusieurs façons :

Pour changer de couleur dans le temps, utilise un dégradé. Les couleurs sont réparties uniformément, et interpolant indique où se trouve la particule sur le dégradé à cet instant :

"minecraft:particle_appearance_tinting": {
  "color": {
    "gradient": {
      "0.0": "#FFFFFFFF",
      "0.3": "#FFFF2650",
      "1.0": "#00600018"
    },
    "interpolant": "variable.particle_age / variable.particle_lifetime"
  }
}

Écrite sous forme d'objet comme ici, chaque couleur se place au point que tu indiques. Une simple liste les répartit plutôt uniformément de 0 à 1. Cette étincelle clignote en blanc, devient rouge rubis assez tôt, puis s'efface lentement.

Éclairage

"minecraft:particle_appearance_lighting": {}

Avec ce composant, les particules paraissent plus sombres dans les grottes et la nuit, pour bien s'intégrer au monde. Ne le mets pas pour ce qui doit briller dans le noir : la magie, le feu, notre étincelle de rubis.

Durée de vie

Ces composants décident du moment où une particule disparaît.

Expression de durée de vie

"minecraft:particle_lifetime_expression": {
  "max_lifetime": "math.random(0.8, 1.5)"
}

• max_lifetime est la durée de vie en secondes, choisie une fois à la naissance de la particule.
• expiration_expression est vérifiée à chaque image. Quand elle ne vaut pas 0, la particule disparaît. Par exemple, "variable.particle_age > 1 && query.is_in_water" pourrait la faire disparaître plus tôt.

Tu peux utiliser les deux ensemble : la particule disparaît dès que l'une des deux conditions est remplie.

Événements de durée de vie

"minecraft:particle_lifetime_events": {
  "creation_event": "flash",
  "expiration_event": "pop",
  "timeline": {
    "0.25": "twinkle"
  }
}

Les noms renvoient au bloc events du même fichier, et chaque champ accepte un nom ou une liste. Contrairement à la version de l'émetteur, ils se déclenchent pour chaque particule, donc une salve de 12 étincelles déclenche pop 12 fois. Voir les événements pour savoir ce qu'un événement peut faire.

Plan de suppression

"minecraft:particle_kill_plane": [0, 1, 0, 0.5]

Les quatre nombres décrivent une surface plate à la façon des maths : tous les points où A*x + B*y + C*z + D = 0, mesurés depuis l'émetteur mais alignés sur le monde. Les particules qui la traversent disparaissent. [0, 1, 0, 0.5] est un sol situé un demi-bloc sous l'émetteur. C'est un moyen peu coûteux d'arrêter des particules qui tombent, sans collision.

Dans des blocs et hors des blocs

"minecraft:particle_expire_if_not_in_blocks": [
  "minecraft:water",
  "minecraft:flowing_water",
  "minecraft:bubble_column"
]

C'est comme ça que les bulles éclatent en atteignant la surface : elles ne vivent que tant qu'elles sont dans l'eau. Utilise particle_expire_if_in_blocks pour l'inverse, par exemple de la poussière qui disparaît dès qu'elle dérive dans l'eau. Les deux fonctionnent avec particle_lifetime_expression.

Une particule complète

Les quatre groupes réunis. Voici le côté particule d'un éclat de rubis qui tombe, rebondit et s'efface :

"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
}

Donne-lui un émetteur tiré des Composants d'émetteur, par exemple une salve de 8 depuis une petite sphère, et tu obtiens un super effet de bloc qui se casse.