Minecraft Bedrock में Particle कंपोनेंट

Minecraft Bedrock के हर particle कंपोनेंट की जानकारी: शुरुआती speed और घुमाव, हरकत, टक्कर (collision), billboard रूप, रंग, रोशनी और उम्र।

Particle कंपोनेंट हर एक particle के बारे में बताते हैं: वह कैसे शुरू होता है, कैसे चलता है, कैसा दिखता है और कब गायब होता है। ये particle फ़ाइल के components block में रहते हैं, उन emitter कंपोनेंट के बगल में जो इन्हें spawn करते हैं।

Particles में नए हैं? आपका पहला particle शून्य से एक ruby चमक बनाता है और इनमें से ज़्यादातर इस्तेमाल करता है।

हर particle को क्या चाहिए

असल में हर effect को particle_lifetime_expression चाहिए (वरना particles कभी गायब नहीं होते) और particle_appearance_billboard चाहिए (वरना दिखने को कुछ होता ही नहीं)। बाकी सब optional है और बेझिझक मिलाया जा सकता है।

नंबर वाली fields एक सादा नंबर या एक Molang string लेती हैं। इनके अंदर आप variable.particle_age, variable.particle_lifetime और variable.particle_random_1 से _4 तक इस्तेमाल कर सकते हैं, ताकि हर particle का अपना अलग अंदाज़ हो।

शुरुआती स्थिति

ये एक बार सेट होते हैं, जब particle पैदा होता है।

कंपोनेंट	यह क्या करता है	मुख्य fields
`minecraft:particle_initial_speed`	Particle कितनी तेज़ी से चलना शुरू करता है	एक नंबर (blocks प्रति सेकंड, emitter shape की दिशा में), या एक `[x, y, z]` speed
`minecraft:particle_initial_spin`	तस्वीर का शुरुआती कोण और वह कितनी तेज़ी से घूमती है	`rotation`: degrees (default 0)। `rotation_rate`: degrees प्रति सेकंड (default 0)
`minecraft:particle_initialization`	हर particle के लिए आपका अपना Molang चलाता है, ताकि वे variables सेट हों जिन्हें दूसरी fields पढ़ती हैं	`per_update_expression`: हर update पर चलता है। `per_render_expression`: हर बार draw होने पर चलता है

Speed

components के अंदर

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

एक नंबर देने पर particle उस दिशा में उड़ता है जो emitter shape ने उसे दी। तीन नंबर देने पर velocity आप खुद सेट करते हैं, जैसे सीधे ऊपर के लिए [0, 2, 0]। इस कंपोनेंट को छोड़ दें तो particles स्थिर शुरू होते हैं।

घुमाव (Spin)

components के अंदर

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

Spin सपाट तस्वीर को उसके केंद्र के चारों ओर घुमाता है, पहिये की तरह। एक random शुरुआती कोण, particles की भीड़ को एक-दूसरे की कॉपी जैसा दिखने से रोकने का सबसे आसान तरीका है।

आपके अपने variables

components के अंदर

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

अब variable.twinkle एक सेकंड में दो बार 0 और 1 के बीच झूलता है, और आप इसे आकार या रंग के लिए इस्तेमाल कर सकते हैं। ऐसी वैल्यू के लिए जो पूरी उम्र में किसी आकार के हिसाब से चले, अक्सर एक curve ज़्यादा आसान होता है।

हरकत (Motion)

ये particle के पैदा होने के बाद उसे हर frame हिलाते हैं।

कंपोनेंट	यह क्या करता है	मुख्य fields
`minecraft:particle_motion_dynamic`	ताकतों (forces) के साथ असली हरकत: gravity, हवा, हवा का प्रतिरोध, घुमाव का तेज़ होना	`linear_acceleration`, `linear_drag_coefficient`, `rotation_acceleration`, `rotation_drag_coefficient`
`minecraft:particle_motion_parametric`	आप Molang से हर frame की सटीक जगह सेट करते हैं, forces को नज़रअंदाज़ करके	`relative_position`, `direction`, `rotation`
`minecraft:particle_motion_collision`	Particles को ब्लॉक से टकराने देता है: उछलना, फिसलना, रुकना या गायब होना	`enabled`, `collision_radius`, `coefficient_of_restitution`, `collision_drag`, `expire_on_contact`, `events`

Dynamic

components के अंदर

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

Field	यह क्या करती है
`linear_acceleration`	हर सेकंड एक धक्का, `[x, y, z]` के रूप में, blocks प्रति सेकंड प्रति सेकंड में। `[0, -9.8, 0]` गिरने जैसा लगता है। Positive y धुएँ की तरह ऊपर तैरता है
`linear_drag_coefficient`	हवा का प्रतिरोध। Particle जितना तेज़ जाता है, उतनी ज़ोर से धीमा होता है। 0 का मतलब कोई प्रतिरोध नहीं
`rotation_acceleration`	घुमाव को तेज़ करता है (या negative वैल्यू से धीमा), degrees प्रति सेकंड प्रति सेकंड में
`rotation_drag_coefficient`	घुमाव को धीमा करता है, ताकि घूमता particle थम जाए

Dynamic हरकत particle की speed पर काम करती है, इसलिए यह particle_initial_speed के साथ मिलकर चलती है: तेज़ शुरुआत करें, फिर gravity और drag को काम करने दें।

Parametric

components के अंदर

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

यहाँ आप physics छोड़कर बस बताते हैं कि particle कहाँ है, emitter से नापकर। यह उदाहरण हर सेकंड एक चक्कर लगाता है और हर सेकंड एक ब्लॉक ऊपर उठता है: एक ruby सर्पिल (spiral)। direction और rotation भी इसी तरह सेट किए जा सकते हैं।

Parametric को सामान्य emitter चाहिए

Parametric हरकत emitter_rate_manual से spawn हुए particles के लिए काम नहीं करती। मॉब से जुड़े effects के लिए यह तभी काम करती है जब emitter अपनी position के लिए local space इस्तेमाल करे।

टक्कर (Collision)

components के अंदर

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

इस कंपोनेंट के बिना particles सीधे ब्लॉक के आर-पार उड़ जाते हैं।

Field	यह क्या करती है
`enabled`	Collision चालू या बंद करती है। Molang हो सकती है, हर frame जाँची जाती है। Default रूप से चालू
`collision_radius`	ब्लॉक से टकराने के लिए particle कितना बड़ा है। आधे ब्लॉक या उससे कम होना चाहिए। इसे मोटे तौर पर billboard के आकार से मिलाएँ
`coefficient_of_restitution`	उछाल। `0` पूरी तरह रुक जाता है, `1` उतनी ही ऊँचाई तक वापस उछलता है, बीच की वैल्यू हर उछाल पर थोड़ी ऊँचाई खोती है
`collision_drag`	सतह छूते समय particle को धीमा करती है, blocks प्रति सेकंड में। इससे वह फिसलकर रुकता है
`expire_on_contact`	`true` करने पर particle ब्लॉक छूते ही हट जाता है। बारिश की बूँदों के लिए अच्छा
`events`	किसी चीज़ से टकराने पर आपका एक event fire करती है, जैसे छींटे (splash)। एक event object या एक लिस्ट। `min_speed` (कम से कम 2 blocks प्रति सेकंड) हल्के छूने को नज़रअंदाज़ करता है

Collision से performance पर असर पड़ता है

हर particle के लिए ब्लॉक जाँचना गेम के लिए मेहनत का काम है। Collision सिर्फ़ वहीं जोड़ें जहाँ फ़र्क दिखे, और ऐसे effects पर max_particles कम रखें।

रूप (Appearance)

ये तय करते हैं कि particle स्क्रीन पर कैसा दिखता है।

कंपोनेंट	यह क्या करता है	मुख्य fields
`minecraft:particle_appearance_billboard`	Particle को एक सपाट तस्वीर की तरह draw करता है और उसका आकार, उसका रुख और texture का कौन-सा हिस्सा दिखेगा, तय करता है	`size`, `facing_camera_mode`, `direction`, `uv`
`minecraft:particle_appearance_tinting`	तस्वीर को रंगता है, एक रंग से या समय के साथ बदलते gradient से	`color`
`minecraft:particle_appearance_lighting`	ब्लॉक की तरह, particle को अंधेरी जगहों पर गहरा और रोशनी में चमकीला बनाता है	कोई नहीं: `{}` लिखें

Billboard

components के अंदर

"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 [width, height] है और हर frame जाँचा जाता है, इसलिए यहाँ Molang से particle को बड़ा या छोटा किया जा सकता है। हर वैल्यू केंद्र से नापी जाती है, इसलिए 0.5 एक ब्लॉक चौड़ा वर्ग बनाता है।

facing_camera_mode तय करता है कि सपाट तस्वीर किस ओर रहेगी:

Mode	तस्वीर
`lookat_xyz`	हमेशा कैमरे की ओर रहती है, लेकिन सीधी खड़ी रहती है। आम विकल्प
`rotate_xyz`	स्क्रीन से सटकर सपाट रहती है, कैमरे के साथ घूमती है
`lookat_y` / `rotate_y`	कैमरे की ओर रहती है लेकिन सिर्फ़ बाएँ-दाएँ घूमती है, ज़मीन पर खड़े cut-out की तरह
`lookat_direction`	Particle की दिशा में सीधी रहते हुए कैमरे की ओर रहती है। लकीरों (streaks) के लिए अच्छा
`direction_x` / `direction_y` / `direction_z`	तस्वीर की x साइड, y साइड या सामने वाले हिस्से को particle की दिशा में रखती है
`emitter_transform_xy` / `_xz` / `_yz`	Emitter के किसी एक plane में सपाट रहती है। `_xz` ज़मीन पर एक सपाट decal बनाता है

Direction वाले modes को जानना होता है कि particle किस ओर है। इसे direction से सेट करें:

minecraft:particle_appearance_billboard के अंदर

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

derive_from_velocity उस दिशा को इस्तेमाल करता है जिधर particle चल रहा है, लेकिन सिर्फ़ तब तक जब तक वह min_speed_threshold से तेज़ चल रहा हो। खुद सेट करने के लिए "custom_direction": [x, y, z] के साथ "mode": "custom_direction" इस्तेमाल करें।

uv texture का वह हिस्सा चुनता है जो दिखाना है। texture_width और texture_height आपकी PNG का आकार pixels में हैं, फिर uv ऊपरी बायाँ कोना है और uv_size उस हिस्से की चौड़ाई और ऊँचाई जो आपको चाहिए। ऊपर का उदाहरण 32x8 की पट्टी का पहला 8x8 frame दिखाता है।

Flipbook animation

कई frames को अगल-बगल रखें और billboard उन्हें flipbook की तरह चला सकता है। uv और uv_size की जगह flipbook लिखें:

uv block के अंदर

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

Field	यह क्या करती है
`base_UV`	पहले frame का ऊपरी बायाँ कोना
`size_UV`	एक frame की चौड़ाई और ऊँचाई
`step_UV`	अगले frame के लिए कितना आगे बढ़ना है। `[8, 0]` दाईं ओर बढ़ता है
`max_frame`	कितने frames हैं (पहला frame 1 है)
`frames_per_second`	चलने की रफ़्तार
`stretch_to_lifetime`	`true` करने पर रफ़्तार नज़रअंदाज़ होती है और सारे frames particle की उम्र में ठीक एक बार चलते हैं
`loop`	`true` करने पर आखिरी के बाद फिर से पहले frame से शुरू होता है

4 frames वाली ruby चमक, जो खुलती है, चमकती है और फिर बंद होती है, एक अकेली तस्वीर से कहीं ज़्यादा जीवंत लगती है।

Tinting

components के अंदर

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

रंग texture से गुणा होता है, इसलिए particle textures सफ़ेद या धूसर (grey) में बनाएँ और रंग tinting को जोड़ने दें। आप रंग इनमें से किसी भी तरीके से लिख सकते हैं:

रूप	उदाहरण
`[r, g, b]` या `[r, g, b, a]`, हर एक 0 से 1	`[1, 0.15, 0.3, 1]`
`"#RRGGBB"`	`"#FF2650"`
`"#AARRGGBB"` (alpha पहले)	`"#80FF2650"` आधा पारदर्शी है
हर slot में Molang	`["variable.tint.r", "variable.tint.g", "variable.tint.b", 1]`

समय के साथ रंग बदलने के लिए gradient इस्तेमाल करें। रंग बराबर फैले होते हैं, और interpolant चुनता है कि इस वक्त particle gradient पर कहाँ है:

components के अंदर

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

इस तरह object के रूप में लिखने पर हर रंग उस बिंदु पर होता है जो आप बताते हैं। सादी लिस्ट उन्हें 0 से 1 तक बराबर फैला देती है। यह चमक पहले सफ़ेद चमकती है, जल्दी ही ruby लाल हो जाती है, फिर धीरे-धीरे फीकी पड़ जाती है।

Alpha को सही material चाहिए

आधे पारदर्शी रंग सिर्फ़ particles_blend या particles_add material के साथ दिखते हैं। particles_alpha के साथ कोई pixel या तो पूरा दिखता है या पूरा छिपा रहता है।

Lighting

components के अंदर

"minecraft:particle_appearance_lighting": {}

इससे particles गुफाओं में और रात को गहरे दिखते हैं, ताकि वे दुनिया में घुल-मिल जाएँ। जो चीज़ें अंधेरे में चमकनी चाहिए, उनके लिए इसे छोड़ दें: जादू, आग, हमारी ruby चमक।

उम्र (Lifetime)

ये तय करते हैं कि particle कब गायब होता है।

कंपोनेंट	यह क्या करता है	मुख्य fields
`minecraft:particle_lifetime_expression`	मुख्य उम्र: एक तय समय, या हर frame जाँचा जाने वाला Molang test	`max_lifetime`, `expiration_expression`
`minecraft:particle_lifetime_events`	हर particle की उम्र के खास पलों पर आपके events fire करता है	`creation_event`, `expiration_event`, `timeline`
`minecraft:particle_kill_plane`	एक अदृश्य सपाट सतह को पार करने वाले particles हटा देता है	`[A, B, C, D]`
`minecraft:particle_expire_if_in_blocks`	लिस्ट में दिए किसी भी ब्लॉक के अंदर मौजूद particles हटा देता है	ब्लॉक नामों की लिस्ट
`minecraft:particle_expire_if_not_in_blocks`	लिस्ट में दिए ब्लॉक से बाहर निकलने वाले particles हटा देता है	ब्लॉक नामों की लिस्ट

Lifetime expression

components के अंदर

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

max_lifetime सेकंड में उम्र है, particle के पैदा होने पर एक बार चुनी जाती है।
expiration_expression हर frame जाँची जाती है। जब यह 0 नहीं होती, particle गायब हो जाता है। जैसे "variable.particle_age > 1 && query.is_in_water" इसे जल्दी खत्म कर सकता है।

आप दोनों एक साथ इस्तेमाल कर सकते हैं: जो पहले हो, particle तभी गायब हो जाता है।

Lifetime events

components के अंदर

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

नाम उसी फ़ाइल के events block की ओर इशारा करते हैं, और हर field एक नाम या एक लिस्ट लेती है। Emitter वाले version के उलट, ये हर एक particle के लिए fire होते हैं, इसलिए 12 चमकों का एक burst pop को 12 बार fire करता है। Event क्या कर सकता है, यह events में देखें।

Kill plane

components के अंदर

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

चार नंबर गणित के तरीके से एक सपाट सतह बताते हैं: वे सारे बिंदु जहाँ A*x + B*y + C*z + D = 0 हो, emitter से नापे गए लेकिन world के हिसाब से सीधे। इसे पार करने वाले particles गायब हो जाते हैं। [0, 1, 0, 0.5] emitter से आधा ब्लॉक नीचे एक फ़र्श है। Collision के बिना गिरते particles को रोकने का यह एक सस्ता तरीका है।

ब्लॉक के अंदर और ब्लॉक के बाहर

components के अंदर

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

इसी तरह बुलबुले सतह पर पहुँचकर फूटते हैं: वे सिर्फ़ पानी के अंदर रहते हुए ही ज़िंदा रहते हैं। उल्टे काम के लिए particle_expire_if_in_blocks इस्तेमाल करें, जैसे धूल जो पानी में बहते ही गायब हो जाए। दोनों particle_lifetime_expression के साथ काम करते हैं।

एक पूरा particle

चारों समूह एक साथ। यह गिरते हुए ruby के टुकड़े का particle वाला हिस्सा है जो उछलता है और फीका पड़ता है:

RP/particles/ruby_shard.json (components के अंदर)

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

इसे Emitter कंपोनेंट से एक emitter दें, जैसे एक छोटे गोले से 8 का burst, और यह ब्लॉक टूटने का एक शानदार effect बनाता है।