आपका पहला पार्टिकल

पार्टिकल वे छोटी चपटी तस्वीरें हैं जो आपको Minecraft में हर जगह दिखती हैं: campfire का धुआँ, खुश जानवर के ऊपर दिल, पानी के नीचे बुलबुले। इस गाइड में आप अपना खुद का बनाएँगे: एक ruby sparkle। यह छोटी-छोटी लाल चमकों का एक झोंका है जो ऊपर तैरती हैं, टिमटिमाती हैं और धीरे-धीरे गायब हो जाती हैं।

आप सीखेंगे कि पार्टिकल फ़ाइल में क्या होता है, उसका texture कैसे बनाएँ, समय के साथ उसे कैसे बदलें और कमांड, ऐनिमेशन या script से उसे गेम में कैसे दिखाएँ।

फ़ाइलें

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

particles फ़ोल्डर की हर .json फ़ाइल गेम लोड करता है। फ़ाइल का नाम मायने नहीं रखता, लेकिन उसे पार्टिकल के नाम जैसा रखने से चीज़ें ढूँढना आसान हो जाता है।

Emitters और पार्टिकल

कुछ भी लिखने से पहले, हर इफ़ेक्ट के दो हिस्से जान लेना काम आता है:

• emitter एक अदृश्य spawner है। यह तय करता है कि कितने पार्टिकल दिखेंगे, वे कहाँ से शुरू होंगे और यह कितनी देर तक spawn करता रहेगा।
• पार्टिकल छोटी तस्वीरें हैं। हर एक तय करता है कि वह कैसे चलेगा, कैसा दिखेगा और कब गायब होगा।

इसीलिए पार्टिकल कंपोनेंट दो परिवारों में आते हैं। minecraft:emitter_ से शुरू होने वाले नाम spawner सेट करते हैं। minecraft:particle_ से शुरू होने वाले नाम हर तस्वीर सेट करते हैं। आप इन्हें किसी भी क्रम में लिख सकते हैं।

स्टेप 1: texture

एक 8x8 PNG बनाएँ और उसे RP/textures/particle/ruby_sparkle.png के रूप में सेव करें। चार कोनों वाला छोटा तारा अच्छा काम करता है।

इसे सफ़ेद और हल्के ग्रे में बनाएँ, लाल में नहीं। बाद में आप इसे एक रंग से tint करेंगे, और tint pixels को गुणा करता है। सफ़ेद आपकी पसंद का कोई भी रंग बन जाता है, लेकिन नीले से tint की गई लाल तस्वीर लगभग काली हो जाएगी।

background पूरी तरह transparent छोड़ें। पार्टिकल हमेशा चपटे चौकोर होते हैं, इसलिए transparent pixels ही उन्हें उनका आकार देते हैं।

स्टेप 2: description

पार्टिकल फ़ाइल बनाएँ और उसके नाम और लुक से शुरू करें:

{
  "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 वह नाम है जिससे आप पार्टिकल चलाते हैं। इसे हमेशा अपना namespace दें (यहाँ wiki:), ताकि यह कभी vanilla या किसी दूसरे ऐड-ऑन से न टकराए।
• texture रिसोर्स पैक के root से आपके PNG का path है, .png के बिना।
• material तय करता है कि आर-पार दिखने वाले pixels कैसे बनें:

हमारी चमक को चमकना चाहिए, इसलिए काम करने के बाद material को particles_add में बदल दें। टेस्टिंग के दौरान particles_alpha से शुरू करें, क्योंकि उसे देखना सबसे आसान है।

स्टेप 3: emitter

अब components भरें। पहले spawner। हमें 12 चमकों का एक तेज़ झोंका चाहिए, एक छोटी गेंद के चारों तरफ़ फैला हुआ:

"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 emitter को एक बार चलाता है और फिर हटा देता है।
• emitter_rate_instant सभी 12 पार्टिकल एक ही पल में spawn करता है।
• emitter_shape_sphere उन्हें 0.4 ब्लॉक radius वाली गेंद के अंदर रखता है, हर एक बीच से बाहर की तरफ़ point करता है।

हर emitter को एक lifetime कंपोनेंट और एक rate कंपोनेंट चाहिए। इनके बिना कुछ भी spawn नहीं होता। आकार optional है: इसे छोड़ दें तो हर पार्टिकल ठीक बीच से शुरू होता है।

स्टेप 4: पार्टिकल

अब हर चमक को बताएँ कि उसे कैसे चलना और दिखना है। इन्हें emitter कंपोनेंट के बाद जोड़ें:

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

हर एक यह करता है:

• Lifetime। हर चमक 0.6 से 1.2 सेकंड के बीच जीती है। math.random हर पार्टिकल के लिए नया नंबर चुनता है, इसलिए वे सब एक साथ गायब नहीं होतीं। यह Molang है, Bedrock की छोटी सी गणित भाषा।
• Speed। वे 1.5 ब्लॉक प्रति सेकंड की रफ़्तार से निकलती हैं, उस दिशा में जो sphere ने उन्हें दी।
• Motion। linear_acceleration उन्हें हर सेकंड थोड़ा ऊपर धकेलता है, ताकि वे अंगारों की तरह तैरें। linear_drag_coefficient हवा का प्रतिरोध है: यह पहले झोंके को जल्दी धीमा कर देता है।
• Billboard। हर पार्टिकल एक चपटा चौकोर है। size ब्लॉक में उसकी आधी चौड़ाई और ऊँचाई है, इसलिए 0.12 लगभग एक चौथाई ब्लॉक चौड़ा चौकोर बनाता है। lookat_xyz इसे खिलाड़ी की तरफ़ घुमाए रखता है।
• UV। यह चुनता है कि texture का कौन सा हिस्सा दिखाना है। हमारा texture एक अकेली 8x8 तस्वीर है, इसलिए हम पूरा इस्तेमाल करते हैं: 0, 0 से शुरू करें और 8, 8 लें।
• Tinting। लाल, हरा, नीला और alpha, हर एक 0 से 1 तक। [1, 0.15, 0.3, 1] रूबी लाल है। आप "#FF2650" भी लिख सकते हैं।

सेव करें, world लोड करें और टाइप करें:

/particle wiki:ruby_sparkle ~ ~1 ~

आपको अपने सामने एक छोटा लाल झोंका ऊपर उठता दिखना चाहिए। अगर कुछ नहीं दिखता, तो इस पेज के आख़िर वाली टेबल देखें।

स्टेप 5: curve से टिमटिमाहट

अभी हर चमक अचानक गायब होने तक एक ही साइज़ में रहती है। curve इसे ठीक करता है। यह एक value है जो उस आकार को फ़ॉलो करती है जो आप कुछ नंबरों से बनाते हैं।

description और components के बगल में एक curves ब्लॉक जोड़ें:

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

• नाम variable. से शुरू होना चाहिए। गेम हर पार्टिकल के लिए, हर frame में curve निकालता है, और जवाब उस variable में रखता है।
• input बताता है कि हम curve पर कहाँ हैं। Age को lifetime से भाग देने पर 0 (अभी पैदा हुआ) से 1 (गायब होने वाला) तक जाता है।
• nodes रास्ते की values हैं, शुरू से आख़िर तक बराबर फैली हुई। हमारी चमक छोटी (0.2) शुरू होती है, पूरे साइज़ (1) तक बढ़ती है, सिकुड़ती है (0.6) और कुछ नहीं (0) पर खत्म होती है।
• type बताता है कि curve nodes के बीच कैसे चलता है। linear सीधी लाइनें बनाता है। catmull_rom और bezier मुलायम मोड़ बनाते हैं, और bezier_chain से आप हर point और ढलान खुद सेट कर सकते हैं।

अब billboard size में variable इस्तेमाल करें:

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

फीका होने के लिए, tint भी पार्टिकल की ज़िंदगी के साथ रंग बदल सकता है। gradient रंगों की लिस्ट देता है, और interpolant चुनता है कि हम उनके बीच कहाँ हैं:

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

यहाँ हर रंग #AARRGGBB के रूप में लिखा है, इसलिए पहले दो अक्षर alpha हैं। चमक हल्के गुलाबी से शुरू होती है, रूबी लाल बनती है और गहरी और अदृश्य होकर खत्म होती है। particles_add के साथ गहरे रंग धीरे-धीरे कुछ नहीं में बदल जाते हैं, जो चमकते इफ़ेक्ट के लिए बहुत सुंदर लगता है।

स्टेप 6: event से एक pop जोड़ें

Events किसी ख़ास पल पर चीज़ें करवाते हैं। चलिए जहाँ हर चमक गायब हो, वहाँ धूल का एक छोटा सा झोंका छोड़ें।

पहले धूल बनाएँ। यह दूसरा, छोटा इफ़ेक्ट है:

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

फिर, ruby_sparkle.json में वापस आकर, एक event का नाम दें और बताएँ कि वह क्या करता है:

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

आख़िर में, जब हर चमक की ज़िंदगी खत्म हो, तब event चलाएँ:

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

event पार्टिकल spawn करने के अलावा और भी कर सकता है:

तैयार फ़ाइल

यह रही पूरी चमक, चमकने वाले material के साथ:

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

हमने चुपके से particle_initial_spin भी डाल दिया है: हर चमक एक random कोण से शुरू होती है और धीरे-धीरे घूमती है, इसलिए कोई दो एक जैसी नहीं दिखतीं।

पार्टिकल चलाना

कमांड से

/particle किसी पोज़िशन पर इफ़ेक्ट चलाता है। इसके लिए cheats चालू होने चाहिए।

/particle wiki:ruby_sparkle ~ ~1 ~

आप इसे किसी function या command block में भी डाल सकते हैं। किसी पर चलाने के लिए execute इस्तेमाल करें: /execute as @a at @s run particle wiki:ruby_sparkle ~ ~2 ~ हर खिलाड़ी के सिर के ऊपर चमक दिखाता है।

मॉब के ऐनिमेशन से

मॉब अपने ऐनिमेशन से पार्टिकल चला सकता है। यह रिसोर्स पैक की क्लाइंट एंटिटी फ़ाइल में होता है, इसलिए अगर आपने अभी तक मॉब नहीं बनाया है, तो पहले आपका पहला कस्टम मॉब देखें।

1. इफ़ेक्ट को एक छोटा नाम दें, क्लाइंट एंटिटी के description में:

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

2. इसे ऐनिमेशन से चलाएँ, किसी समय पर। locator optional है: यह मॉडल पर एक नाम वाला point है, और मॉब के चलने पर इफ़ेक्ट उसके साथ चलता है। इसके बिना, यह मॉब के पैरों पर चलता है।

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

3. या इसे ऐनिमेशन कंट्रोलर स्टेट से चलाएँ। यह तब शुरू होता है जब मॉब उस स्टेट में प्रवेश करता है:

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

इनमें से हर एक में pre_effect_script भी हो सकता है: थोड़ा सा Molang जो इफ़ेक्ट शुरू होने से ठीक पहले चलता है। इससे पार्टिकल फ़ाइल में values भेजें, जैसे ऐसा रंग जो मॉब पर निर्भर हो।

script से

Scripts कहीं भी, कभी भी पार्टिकल चला सकती हैं। आपके बिहेवियर पैक के manifest में एक script module होना चाहिए: प्रोजेक्ट सेटअप में दिखाया गया है कैसे।

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 });
});

हर बार जब कोई खिलाड़ी wiki:ruby_wand आइटम इस्तेमाल करता है, उसके ऊपर एक चमक फूटती है। dimension.spawnParticle इफ़ेक्ट को पास के सभी लोगों को दिखाता है। player.spawnParticle भी ऐसे ही काम करता है, लेकिन इसे सिर्फ़ वही एक खिलाड़ी देखता है।

Scripts MolangVariableMap से पार्टिकल में values भी भेज सकती हैं। इससे एक ही पार्टिकल फ़ाइल किसी भी रंग की चमक बना सकती है:

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);

पार्टिकल फ़ाइल में, रंग के तीन हिस्सों को variable.tint.r, variable.tint.g और variable.tint.b के रूप में पढ़ें:

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

काम के Molang variables

गेम ये values आपके लिए भर देता है। इन्हें किसी भी Molang फ़ील्ड में इस्तेमाल करें।

variable.particle_random_1 विविधता के लिए बढ़िया है। उदाहरण के लिए "0.1 + variable.particle_random_1 * 0.05" हर चमक को थोड़ा अलग साइज़ देता है।

जब कुछ गड़बड़ हो

और मदद Troubleshooting में है। और सीखने के लिए तैयार? हर emitter setting Emitter कंपोनेंट पर है, और हर पार्टिकल setting Particle कंपोनेंट पर।