ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ ਸੀ #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ. '] ", 'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ.', ' [\'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ ਸੀ #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nusingਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕ ਬੂਲ ਸਮਰੱਥ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਇਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕ ਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\nNAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਜੇਕਰ (Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਪ੍ਰੋਬੇਬਿਲਟੀ ਲਿਸਟ [Random.Range (0, probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawed; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ + transform.position; \\n ਇੰਸਟੈਂਟੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0,prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n {\\n ਨੰਮਸਪੌਨਡ + +; \\n} \\n ਜੇਕਰ (ਨੰਮਸਪੌਨਡ> = ਨੰਮਸਪੌਨਡ *ਸਪੌਨ ਇੰਟਰਵਲ) \\n {\\n ਜੇਕਰ (! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \\n} \\n} \\n "\'\\n ਇਹ ਸਕ੍ਰਿਪਟ ਤੁਹਾਨੂੰ ਸਪੌਨਰ ਨੂੰ ਸਮਰੱਥ/ਅਯੋਗ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਸੈੱਟ ਕਰੋਸਪੌਨਾਂ ਵਿਚਕਾਰ ਅੰਤਰਾਲ, ਨਾਮ _ 1 ਲਈ ਵਸਤੂਆਂ ਦੀ ਗਿਣਤੀ, ਅਤੇ ਸਪੌਨਰ ਦੇ ਆਲੇ ਦੁਆਲੇ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸ। ਇਸ ਵਿੱਚ ਇੱਕ ਪ੍ਰੀਫੈਬ ਵੀ ਹੁੰਦਾ ਹੈ।ਸੂਚੀ ਅਤੇ ਸੰਭਾਵਨਾ ਸੂਚੀ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਕਿ ਕੀ ਪੈਦਾ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਨਾਮ _ 1 ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ। ਸਕ੍ਰਿਪਟ ਇੱਕ ਫਾਰ ਲੂਪ ਨੂੰ ਨਾਮ _ 1 ਲਈ ਵਰਤਦੀ ਹੈ ਜਿਸ ਉੱਤੇ ਪ੍ਰੀਫੈਬ ਹੁੰਦੇ ਹਨ।ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ, ਅਤੇ ਸਿਰਫ ਨਾਮ _ 1 ਵਸਤੂਆਂ ਲਈ ਇੱਕ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੇ ਅੰਤਰਾਲ ਆਖਰੀ ਨਾਮ _ 1 ਤੋਂ ਲੰਘ ਗਿਆ ਹੈ।ਪੈਦਾ ਕੀਤੀਆਂ ਗਈਆਂ ਵਸਤੂਆਂ ਦੀ ਗਿਣਤੀ \'ਨੰਬਰ\' ਤੋਂ ਵੱਧ ਹੈ, \'ਤੁਸੀਂ Input.GetKeyDown ਕਿਉਂ ਜੋਡ਼ਿਆ?\' ', 'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ.', ' [\'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ ਸੀ #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nusingਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕ ਬੂਲ ਸਮਰੱਥ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਇਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕ ਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\nNAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਜੇਕਰ (Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਪ੍ਰੋਬੇਬਿਲਟੀ ਲਿਸਟ [Random.Range (0, probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawed; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ + transform.position; \\n ਇੰਸਟੈਂਟੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0,prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n {\\n ਨੰਮਸਪੌਨਡ + +; \\n} \\n ਜੇਕਰ (ਨੰਮਸਪੌਨਡ> = ਨੰਮਸਪੌਨਡ *ਸਪੌਨ ਇੰਟਰਵਲ) \\n {\\n ਜੇਕਰ (! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \\n} \\n} \\n "\'\\n ਇਹ ਸਕ੍ਰਿਪਟ ਤੁਹਾਨੂੰ ਸਪੌਨਰ ਨੂੰ ਸਮਰੱਥ/ਅਯੋਗ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਸੈੱਟ ਕਰੋਸਪੌਨਾਂ ਵਿਚਕਾਰ ਅੰਤਰਾਲ, ਨਾਮ _ 1 ਲਈ ਵਸਤੂਆਂ ਦੀ ਗਿਣਤੀ, ਅਤੇ ਸਪੌਨਰ ਦੇ ਆਲੇ ਦੁਆਲੇ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸ। ਇਸ ਵਿੱਚ ਇੱਕ ਪ੍ਰੀਫੈਬ ਵੀ ਹੁੰਦਾ ਹੈ।ਸੂਚੀ ਅਤੇ ਸੰਭਾਵਨਾ ਸੂਚੀ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਕਿ ਕੀ ਪੈਦਾ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਨਾਮ _ 1 ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ। ਸਕ੍ਰਿਪਟ ਇੱਕ ਫਾਰ ਲੂਪ ਨੂੰ ਨਾਮ _ 1 ਲਈ ਵਰਤਦੀ ਹੈ ਜਿਸ ਉੱਤੇ ਪ੍ਰੀਫੈਬ ਹੁੰਦੇ ਹਨ।ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ, ਅਤੇ ਸਿਰਫ ਨਾਮ _ 1 ਵਸਤੂਆਂ ਲਈ ਇੱਕ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੇ ਅੰਤਰਾਲ ਆਖਰੀ ਨਾਮ _ 1 ਤੋਂ ਲੰਘ ਗਿਆ ਹੈ।\',\' ਤੁਸੀਂ Input.GetKeyDown ਕਿਉਂ ਜੋਡ਼ਿਆ? \',\' ਮੈਂ ਅੱਪਡੇਟ () ਵਿਧੀ ਵਿੱਚ Input.GetKeyDown () ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਹੈ।ਸਪੇਸ ਬਾਰ ਦਬਾ ਕੇ ਉਪਭੋਗਤਾ ਨੂੰ ਨਾਮ _ 1 ਆਬਜੈਕਟ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ। ਇਹ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਜੇ ਨਹੀਂ ਤਾਂ ਇਸ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।\',\' ਜੇਕਰ ਕੋਈ ਪ੍ਰੀਫੈਬ ਤੁਰੰਤ ਨਹੀਂ ਹੈ ਤਾਂ ਸੰਖਿਆ ਵਾਧਾ ਕਿਉਂ ਹੁੰਦਾ ਹੈ? \' ', 'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ.', ' [\'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ ਸੀ #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nusingਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕ ਬੂਲ ਸਮਰੱਥ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਇਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕ ਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\nNAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਜੇਕਰ (Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਪ੍ਰੋਬੇਬਿਲਟੀ ਲਿਸਟ [Random.Range (0, probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawed; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ + transform.position; \\n ਇੰਸਟੈਂਟੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0,prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n {\\n ਨੰਮਸਪੌਨਡ + +; \\n} \\n ਜੇਕਰ (ਨੰਮਸਪੌਨਡ> = ਨੰਮਸਪੌਨਡ *ਸਪੌਨ ਇੰਟਰਵਲ) \\n {\\n ਜੇਕਰ (! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \\n} \\n} \\n "\'\\n ਇਹ ਸਕ੍ਰਿਪਟ ਤੁਹਾਨੂੰ ਸਪੌਨਰ ਨੂੰ ਸਮਰੱਥ/ਅਯੋਗ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਸੈੱਟ ਕਰੋਸਪੌਨਾਂ ਵਿਚਕਾਰ ਅੰਤਰਾਲ, ਨਾਮ _ 1 ਲਈ ਵਸਤੂਆਂ ਦੀ ਗਿਣਤੀ, ਅਤੇ ਸਪੌਨਰ ਦੇ ਆਲੇ ਦੁਆਲੇ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸ। ਇਸ ਵਿੱਚ ਇੱਕ ਪ੍ਰੀਫੈਬ ਵੀ ਹੁੰਦਾ ਹੈ।ਸੂਚੀ ਅਤੇ ਸੰਭਾਵਨਾ ਸੂਚੀ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਕਿ ਕੀ ਪੈਦਾ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਨਾਮ _ 1 ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ। ਸਕ੍ਰਿਪਟ ਇੱਕ ਫਾਰ ਲੂਪ ਨੂੰ ਨਾਮ _ 1 ਲਈ ਵਰਤਦੀ ਹੈ ਜਿਸ ਉੱਤੇ ਪ੍ਰੀਫੈਬ ਹੁੰਦੇ ਹਨ।ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ, ਅਤੇ ਸਿਰਫ ਨਾਮ _ 1 ਵਸਤੂਆਂ ਲਈ ਇੱਕ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੇ ਅੰਤਰਾਲ ਆਖਰੀ ਨਾਮ _ 1 ਤੋਂ ਲੰਘ ਗਿਆ ਹੈ।\',\' ਤੁਸੀਂ Input.GetKeyDown ਕਿਉਂ ਜੋਡ਼ਿਆ? \',\' ਮੈਂ ਅੱਪਡੇਟ () ਵਿਧੀ ਵਿੱਚ Input.GetKeyDown () ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਹੈ।ਸਪੇਸ ਬਾਰ ਦਬਾ ਕੇ ਉਪਭੋਗਤਾ ਨੂੰ ਨਾਮ _ 1 ਆਬਜੈਕਟ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ। ਇਹ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਜੇ ਨਹੀਂ ਤਾਂ ਇਸ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।\',\' ਜੇਕਰ ਕੋਈ ਪ੍ਰੀਫੈਬ ਇੰਸਟੈਂਸ਼ੀਏਟ ਨਹੀਂ ਹੈ ਤਾਂ ਨੰਮਸਪਾਨਡ ਇੰਕਰੀਮੈਂਟ ਕਿਉਂ ਹੁੰਦਾ ਹੈ। \',\' ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂਆਂ \'ਤੇ NAME _ 1 ਪ੍ਰੀਫੈਬ ਲਈ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਨਿਰਧਾਰਤ ਰੇਡੀਅਸ। ਲੂਪ ਸੰਭਾਵਨਾ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਰੈਂਡਮ ਇੰਡੈਕਸ ਦੀ ਚੋਣ ਕਰਨ ਲਈ Random.Range () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਬਣਾਉਣ ਲਈ ਇੰਸਟੈਂਸ਼ੀਏਟ () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਚੁਣੇ ਬਿੰਦੂ ਉੱਤੇ ਨਵਾਂ ਆਬਜੈਕਟ। ਜੇਕਰ ਚੁਣਿਆ ਇੰਡੈਕਸ 0 ਦੀ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਲੂਪ ਅਗਲੇ ਦੁਹਰਾਓ ਲਈ ਜਾਰੀ ਰਹੇਗਾ ਅਤੇ ਉਸ ਪ੍ਰੀਫੈਬ ਨੂੰ ਛੱਡ ਦੇਵੇਗਾ।ਹਾਲਾਂਕਿ, ਜੇਕਰ ਚੁਣਿਆ ਸੂਚਕਾਂਕ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਪ੍ਰੀਫੈਬ ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਉੱਤੇ ਪੈਦਾ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਜੇ ਨਹੀਂਪ੍ਰੀਫੈਬ ਦੀ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੁੰਦੀ ਹੈ, ਫਿਰ ਲੂਪ ਸਿਰਫ ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਨਾਵਾਂ ਵਾਲੇ ਪ੍ਰੀਫੈਬਾਂ ਨੂੰ ਨਾਮ _ 1 ਦੇਵੇਗਾ, ਅਤੇ ਨੰਮਸਪਾਨਡ ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਹੀਂਨਵੀਆਂ ਵਸਤੂਆਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹੋ \'numSpaund ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਾ ਕੀਤੀ ਗਈ ਹੋਵੇ।\'] ', 'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ.', ' [\'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ ਸੀ #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nusingਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕ ਬੂਲ ਸਮਰੱਥ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਇਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕ ਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\nNAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਜੇਕਰ (Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਪ੍ਰੋਬੇਬਿਲਟੀ ਲਿਸਟ [Random.Range (0, probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawed; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ + transform.position; \\n ਇੰਸਟੈਂਟੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0,prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n {\\n ਨੰਮਸਪੌਨਡ + +; \\n} \\n ਜੇਕਰ (ਨੰਮਸਪੌਨਡ> = ਨੰਮਸਪੌਨਡ *ਸਪੌਨ ਇੰਟਰਵਲ) \\n {\\n ਜੇਕਰ (! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \\n} \\n} \\n "\'\\n ਇਹ ਸਕ੍ਰਿਪਟ ਤੁਹਾਨੂੰ ਸਪੌਨਰ ਨੂੰ ਸਮਰੱਥ/ਅਯੋਗ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਸੈੱਟ ਕਰੋਸਪੌਨਾਂ ਵਿਚਕਾਰ ਅੰਤਰਾਲ, ਨਾਮ _ 1 ਲਈ ਵਸਤੂਆਂ ਦੀ ਗਿਣਤੀ, ਅਤੇ ਸਪੌਨਰ ਦੇ ਆਲੇ ਦੁਆਲੇ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸ। ਇਸ ਵਿੱਚ ਇੱਕ ਪ੍ਰੀਫੈਬ ਵੀ ਹੁੰਦਾ ਹੈ।ਸੂਚੀ ਅਤੇ ਸੰਭਾਵਨਾ ਸੂਚੀ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਕਿ ਕੀ ਪੈਦਾ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਨਾਮ _ 1 ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ। ਸਕ੍ਰਿਪਟ ਇੱਕ ਫਾਰ ਲੂਪ ਨੂੰ ਨਾਮ _ 1 ਲਈ ਵਰਤਦੀ ਹੈ ਜਿਸ ਉੱਤੇ ਪ੍ਰੀਫੈਬ ਹੁੰਦੇ ਹਨ।ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ, ਅਤੇ ਸਿਰਫ ਨਾਮ _ 1 ਵਸਤੂਆਂ ਲਈ ਇੱਕ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੇ ਅੰਤਰਾਲ ਆਖਰੀ ਨਾਮ _ 1 ਤੋਂ ਲੰਘ ਗਿਆ ਹੈ।\',\' ਤੁਸੀਂ Input.GetKeyDown ਕਿਉਂ ਜੋਡ਼ਿਆ? \',\' ਮੈਂ ਅੱਪਡੇਟ () ਵਿਧੀ ਵਿੱਚ Input.GetKeyDown () ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਹੈ।ਸਪੇਸ ਬਾਰ ਦਬਾ ਕੇ ਉਪਭੋਗਤਾ ਨੂੰ ਨਾਮ _ 1 ਆਬਜੈਕਟ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ। ਇਹ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਜੇ ਨਹੀਂ ਤਾਂ ਇਸ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।\',\' ਜੇਕਰ ਕੋਈ ਪ੍ਰੀਫੈਬ ਇੰਸਟੈਂਸ਼ੀਏਟ ਨਹੀਂ ਹੈ ਤਾਂ ਨੰਮਸਪਾਨਡ ਇੰਕਰੀਮੈਂਟ ਕਿਉਂ ਹੁੰਦਾ ਹੈ। \',\' ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂਆਂ \'ਤੇ NAME _ 1 ਪ੍ਰੀਫੈਬ ਲਈ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਨਿਰਧਾਰਤ ਰੇਡੀਅਸ। ਲੂਪ ਸੰਭਾਵਨਾ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਰੈਂਡਮ ਇੰਡੈਕਸ ਦੀ ਚੋਣ ਕਰਨ ਲਈ Random.Range () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਬਣਾਉਣ ਲਈ ਇੰਸਟੈਂਸ਼ੀਏਟ () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਚੁਣੇ ਬਿੰਦੂ ਉੱਤੇ ਨਵਾਂ ਆਬਜੈਕਟ। ਜੇਕਰ ਚੁਣਿਆ ਇੰਡੈਕਸ 0 ਦੀ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਲੂਪ ਅਗਲੇ ਦੁਹਰਾਓ ਲਈ ਜਾਰੀ ਰਹੇਗਾ ਅਤੇ ਉਸ ਪ੍ਰੀਫੈਬ ਨੂੰ ਛੱਡ ਦੇਵੇਗਾ।ਹਾਲਾਂਕਿ, ਜੇਕਰ ਚੁਣਿਆ ਸੂਚਕਾਂਕ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਪ੍ਰੀਫੈਬ ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਉੱਤੇ ਪੈਦਾ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਜੇ ਨਹੀਂਪ੍ਰੀਫੈਬ ਦੀ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੁੰਦੀ ਹੈ, ਫਿਰ ਲੂਪ ਸਿਰਫ ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਨਾਵਾਂ ਵਾਲੇ ਪ੍ਰੀਫੈਬਾਂ ਨੂੰ ਨਾਮ _ 1 ਦੇਵੇਗਾ, ਅਤੇ ਨੰਮਸਪਾਨਡ ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਹੀਂਨਵੀਆਂ ਵਸਤੂਆਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹੋ \'numSpaund ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਾ ਕੀਤੀ ਗਈ ਹੋਵੇ।\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਅੱਪਡੇਟ ਕੀਤੀ ਸਕ੍ਰਿਪਟ ਹੈ।ਜੇਕਰ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਤਾਂ ਲਾਈਨ ਤੋਂ ਬਿਨਾਂ ਜੋ ਨੰਮਸ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈਃ \\n \'\\nਊਜ਼ਿੰਗ ਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕਬੂਲ ਇਨੇਬਲ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ(Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਸੰਭਾਵਨਾ ਸੂਚੀ [Random.Range (0,probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawnd; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ +transform.position; \\n ਇੰਸਟੈਂਸ਼ੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0, prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n{\\n numSpawned + +; \\n} \\n ਜੇਕਰ (numSpawned> = numSpawned * spawnInterval) \\n {\\n ਜੇਕਰ (! enableSpawner) \\n {\\n enable = false; \\n} \\n} \\n \',\' ਕੀ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ?ਮੈਨੂੰ ਹਟਾਈਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਦਿਖਾਓ? \' ', 'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ.', ' [\'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ ਸੀ #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nusingਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕ ਬੂਲ ਸਮਰੱਥ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਇਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕ ਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\nNAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਜੇਕਰ (Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਪ੍ਰੋਬੇਬਿਲਟੀ ਲਿਸਟ [Random.Range (0, probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawed; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ + transform.position; \\n ਇੰਸਟੈਂਟੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0,prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n {\\n ਨੰਮਸਪੌਨਡ + +; \\n} \\n ਜੇਕਰ (ਨੰਮਸਪੌਨਡ> = ਨੰਮਸਪੌਨਡ *ਸਪੌਨ ਇੰਟਰਵਲ) \\n {\\n ਜੇਕਰ (! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \\n} \\n} \\n "\'\\n ਇਹ ਸਕ੍ਰਿਪਟ ਤੁਹਾਨੂੰ ਸਪੌਨਰ ਨੂੰ ਸਮਰੱਥ/ਅਯੋਗ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਸੈੱਟ ਕਰੋਸਪੌਨਾਂ ਵਿਚਕਾਰ ਅੰਤਰਾਲ, ਨਾਮ _ 1 ਲਈ ਵਸਤੂਆਂ ਦੀ ਗਿਣਤੀ, ਅਤੇ ਸਪੌਨਰ ਦੇ ਆਲੇ ਦੁਆਲੇ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸ। ਇਸ ਵਿੱਚ ਇੱਕ ਪ੍ਰੀਫੈਬ ਵੀ ਹੁੰਦਾ ਹੈ।ਸੂਚੀ ਅਤੇ ਸੰਭਾਵਨਾ ਸੂਚੀ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਕਿ ਕੀ ਪੈਦਾ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਨਾਮ _ 1 ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ। ਸਕ੍ਰਿਪਟ ਇੱਕ ਫਾਰ ਲੂਪ ਨੂੰ ਨਾਮ _ 1 ਲਈ ਵਰਤਦੀ ਹੈ ਜਿਸ ਉੱਤੇ ਪ੍ਰੀਫੈਬ ਹੁੰਦੇ ਹਨ।ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ, ਅਤੇ ਸਿਰਫ ਨਾਮ _ 1 ਵਸਤੂਆਂ ਲਈ ਇੱਕ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੇ ਅੰਤਰਾਲ ਆਖਰੀ ਨਾਮ _ 1 ਤੋਂ ਲੰਘ ਗਿਆ ਹੈ।\',\' ਤੁਸੀਂ Input.GetKeyDown ਕਿਉਂ ਜੋਡ਼ਿਆ? \',\' ਮੈਂ ਅੱਪਡੇਟ () ਵਿਧੀ ਵਿੱਚ Input.GetKeyDown () ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਹੈ।ਸਪੇਸ ਬਾਰ ਦਬਾ ਕੇ ਉਪਭੋਗਤਾ ਨੂੰ ਨਾਮ _ 1 ਆਬਜੈਕਟ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ। ਇਹ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਜੇ ਨਹੀਂ ਤਾਂ ਇਸ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।\',\' ਜੇਕਰ ਕੋਈ ਪ੍ਰੀਫੈਬ ਇੰਸਟੈਂਸ਼ੀਏਟ ਨਹੀਂ ਹੈ ਤਾਂ ਨੰਮਸਪਾਨਡ ਇੰਕਰੀਮੈਂਟ ਕਿਉਂ ਹੁੰਦਾ ਹੈ। \',\' ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂਆਂ \'ਤੇ NAME _ 1 ਪ੍ਰੀਫੈਬ ਲਈ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਨਿਰਧਾਰਤ ਰੇਡੀਅਸ। ਲੂਪ ਸੰਭਾਵਨਾ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਰੈਂਡਮ ਇੰਡੈਕਸ ਦੀ ਚੋਣ ਕਰਨ ਲਈ Random.Range () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਬਣਾਉਣ ਲਈ ਇੰਸਟੈਂਸ਼ੀਏਟ () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਚੁਣੇ ਬਿੰਦੂ ਉੱਤੇ ਨਵਾਂ ਆਬਜੈਕਟ। ਜੇਕਰ ਚੁਣਿਆ ਇੰਡੈਕਸ 0 ਦੀ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਲੂਪ ਅਗਲੇ ਦੁਹਰਾਓ ਲਈ ਜਾਰੀ ਰਹੇਗਾ ਅਤੇ ਉਸ ਪ੍ਰੀਫੈਬ ਨੂੰ ਛੱਡ ਦੇਵੇਗਾ।ਹਾਲਾਂਕਿ, ਜੇਕਰ ਚੁਣਿਆ ਸੂਚਕਾਂਕ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਪ੍ਰੀਫੈਬ ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਉੱਤੇ ਪੈਦਾ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਜੇ ਨਹੀਂਪ੍ਰੀਫੈਬ ਦੀ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੁੰਦੀ ਹੈ, ਫਿਰ ਲੂਪ ਸਿਰਫ ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਨਾਵਾਂ ਵਾਲੇ ਪ੍ਰੀਫੈਬਾਂ ਨੂੰ ਨਾਮ _ 1 ਦੇਵੇਗਾ, ਅਤੇ ਨੰਮਸਪਾਨਡ ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਹੀਂਨਵੀਆਂ ਵਸਤੂਆਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹੋ \'numSpaund ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਾ ਕੀਤੀ ਗਈ ਹੋਵੇ।\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਅੱਪਡੇਟ ਕੀਤੀ ਸਕ੍ਰਿਪਟ ਹੈ।ਜੇਕਰ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਤਾਂ ਲਾਈਨ ਤੋਂ ਬਿਨਾਂ ਜੋ ਨੰਮਸ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈਃ \\n \'\\nਊਜ਼ਿੰਗ ਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕਬੂਲ ਇਨੇਬਲ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ(Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਸੰਭਾਵਨਾ ਸੂਚੀ [Random.Range (0,probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawnd; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ +transform.position; \\n ਇੰਸਟੈਂਸ਼ੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0, prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n{\\n numSpawned + +; \\n} \\n ਜੇਕਰ (numSpawned> = numSpawned * spawnInterval) \\n {\\n ਜੇਕਰ (! enableSpawner) \\n {\\n enable = false; \\n} \\n} \\n \',\' ਕੀ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ?ਮੈਨੂੰ ਹਟਾਈਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਵੇਖੋ? \',\' ਯਕੀਨਨ, ਇਹ ਉਹ ਲਾਈਨਾਂ ਹਨ ਜੋ ਹਟਾਈਆਂ ਗਈਆਂ ਸਨਃ \\n \'if (numSpawned> = numSpawned * spanInterval) \\n {\\n ਜੇਕਰ(! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \'\\n ਇਹ ਲਾਈਨਾਂ ਹਟਾ ਦਿੱਤੀਆਂ ਗਈਆਂ ਸਨ ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੀਆਂ ਸਨ ਅਤੇ ਇਹਨਾਂ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਵਿੱਚ ਯੋਗਦਾਨ ਨਹੀਂ ਪਾਉਂਦੀਆਂ ਸਨ।ਸਕ੍ਰਿਪਟ. \',\' ਤੁਹਾਨੂੰ ਧੰਨਵਾਦ, ਇਹ ਪਹਿਲੀ ਵਾਰ ਹੈ ਜਦੋਂ ਮੈਂ ਇੰਸਾਈਡਯੂਨਿਟਸਫੀਅਰ ਬਾਰੇ ਸੁਣਿਆ ਹੈ ਅਤੇ ਇਹ ਭਵਿੱਖ ਲਈ ਬਹੁਤ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ! \' ', 'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ.', ' [\'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ ਸੀ #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nusingਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕ ਬੂਲ ਸਮਰੱਥ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਇਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕ ਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\nNAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਜੇਕਰ (Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਪ੍ਰੋਬੇਬਿਲਟੀ ਲਿਸਟ [Random.Range (0, probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawed; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ + transform.position; \\n ਇੰਸਟੈਂਟੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0,prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n {\\n ਨੰਮਸਪੌਨਡ + +; \\n} \\n ਜੇਕਰ (ਨੰਮਸਪੌਨਡ> = ਨੰਮਸਪੌਨਡ *ਸਪੌਨ ਇੰਟਰਵਲ) \\n {\\n ਜੇਕਰ (! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \\n} \\n} \\n "\'\\n ਇਹ ਸਕ੍ਰਿਪਟ ਤੁਹਾਨੂੰ ਸਪੌਨਰ ਨੂੰ ਸਮਰੱਥ/ਅਯੋਗ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਸੈੱਟ ਕਰੋਸਪੌਨਾਂ ਵਿਚਕਾਰ ਅੰਤਰਾਲ, ਨਾਮ _ 1 ਲਈ ਵਸਤੂਆਂ ਦੀ ਗਿਣਤੀ, ਅਤੇ ਸਪੌਨਰ ਦੇ ਆਲੇ ਦੁਆਲੇ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸ। ਇਸ ਵਿੱਚ ਇੱਕ ਪ੍ਰੀਫੈਬ ਵੀ ਹੁੰਦਾ ਹੈ।ਸੂਚੀ ਅਤੇ ਸੰਭਾਵਨਾ ਸੂਚੀ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਕਿ ਕੀ ਪੈਦਾ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਨਾਮ _ 1 ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ। ਸਕ੍ਰਿਪਟ ਇੱਕ ਫਾਰ ਲੂਪ ਨੂੰ ਨਾਮ _ 1 ਲਈ ਵਰਤਦੀ ਹੈ ਜਿਸ ਉੱਤੇ ਪ੍ਰੀਫੈਬ ਹੁੰਦੇ ਹਨ।ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ, ਅਤੇ ਸਿਰਫ ਨਾਮ _ 1 ਵਸਤੂਆਂ ਲਈ ਇੱਕ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੇ ਅੰਤਰਾਲ ਆਖਰੀ ਨਾਮ _ 1 ਤੋਂ ਲੰਘ ਗਿਆ ਹੈ।\',\' ਤੁਸੀਂ Input.GetKeyDown ਕਿਉਂ ਜੋਡ਼ਿਆ? \',\' ਮੈਂ ਅੱਪਡੇਟ () ਵਿਧੀ ਵਿੱਚ Input.GetKeyDown () ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਹੈ।ਸਪੇਸ ਬਾਰ ਦਬਾ ਕੇ ਉਪਭੋਗਤਾ ਨੂੰ ਨਾਮ _ 1 ਆਬਜੈਕਟ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ। ਇਹ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਜੇ ਨਹੀਂ ਤਾਂ ਇਸ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।\',\' ਜੇਕਰ ਕੋਈ ਪ੍ਰੀਫੈਬ ਇੰਸਟੈਂਸ਼ੀਏਟ ਨਹੀਂ ਹੈ ਤਾਂ ਨੰਮਸਪਾਨਡ ਇੰਕਰੀਮੈਂਟ ਕਿਉਂ ਹੁੰਦਾ ਹੈ। \',\' ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂਆਂ \'ਤੇ NAME _ 1 ਪ੍ਰੀਫੈਬ ਲਈ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਨਿਰਧਾਰਤ ਰੇਡੀਅਸ। ਲੂਪ ਸੰਭਾਵਨਾ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਰੈਂਡਮ ਇੰਡੈਕਸ ਦੀ ਚੋਣ ਕਰਨ ਲਈ Random.Range () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਬਣਾਉਣ ਲਈ ਇੰਸਟੈਂਸ਼ੀਏਟ () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਚੁਣੇ ਬਿੰਦੂ ਉੱਤੇ ਨਵਾਂ ਆਬਜੈਕਟ। ਜੇਕਰ ਚੁਣਿਆ ਇੰਡੈਕਸ 0 ਦੀ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਲੂਪ ਅਗਲੇ ਦੁਹਰਾਓ ਲਈ ਜਾਰੀ ਰਹੇਗਾ ਅਤੇ ਉਸ ਪ੍ਰੀਫੈਬ ਨੂੰ ਛੱਡ ਦੇਵੇਗਾ।ਹਾਲਾਂਕਿ, ਜੇਕਰ ਚੁਣਿਆ ਸੂਚਕਾਂਕ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਪ੍ਰੀਫੈਬ ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਉੱਤੇ ਪੈਦਾ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਜੇ ਨਹੀਂਪ੍ਰੀਫੈਬ ਦੀ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੁੰਦੀ ਹੈ, ਫਿਰ ਲੂਪ ਸਿਰਫ ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਨਾਵਾਂ ਵਾਲੇ ਪ੍ਰੀਫੈਬਾਂ ਨੂੰ ਨਾਮ _ 1 ਦੇਵੇਗਾ, ਅਤੇ ਨੰਮਸਪਾਨਡ ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਹੀਂਨਵੀਆਂ ਵਸਤੂਆਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹੋ \'numSpaund ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਾ ਕੀਤੀ ਗਈ ਹੋਵੇ।\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਅੱਪਡੇਟ ਕੀਤੀ ਸਕ੍ਰਿਪਟ ਹੈ।ਜੇਕਰ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਤਾਂ ਲਾਈਨ ਤੋਂ ਬਿਨਾਂ ਜੋ ਨੰਮਸ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈਃ \\n \'\\nਊਜ਼ਿੰਗ ਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕਬੂਲ ਇਨੇਬਲ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ(Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਸੰਭਾਵਨਾ ਸੂਚੀ [Random.Range (0,probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawnd; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ +transform.position; \\n ਇੰਸਟੈਂਸ਼ੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0, prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n{\\n numSpawned + +; \\n} \\n ਜੇਕਰ (numSpawned> = numSpawned * spawnInterval) \\n {\\n ਜੇਕਰ (! enableSpawner) \\n {\\n enable = false; \\n} \\n} \\n \',\' ਕੀ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ?ਮੈਨੂੰ ਹਟਾਈਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਵੇਖੋ? \',\' ਯਕੀਨਨ, ਇਹ ਉਹ ਲਾਈਨਾਂ ਹਨ ਜੋ ਹਟਾਈਆਂ ਗਈਆਂ ਸਨਃ \\n \'if (numSpawned> = numSpawned * spanInterval) \\n {\\n ਜੇਕਰ(! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \'\\n ਇਹ ਲਾਈਨਾਂ ਹਟਾ ਦਿੱਤੀਆਂ ਗਈਆਂ ਸਨ ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੀਆਂ ਸਨ ਅਤੇ ਇਹਨਾਂ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਵਿੱਚ ਯੋਗਦਾਨ ਨਹੀਂ ਪਾਉਂਦੀਆਂ ਸਨ।ਸਕ੍ਰਿਪਟ। \',\' ਤੁਹਾਨੂੰ ਧੰਨਵਾਦ, ਇਹ ਪਹਿਲੀ ਵਾਰ ਹੈ ਜਦੋਂ ਮੈਂ ਇੰਸਾਈਡਯੂਨਿਟਸਫੀਅਰ ਬਾਰੇ ਸੁਣਿਆ ਹੈ ਅਤੇ ਇਹ ਭਵਿੱਖ ਲਈ ਬਹੁਤ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ! \',\' ਤੁਹਾਡਾ ਸਵਾਗਤ ਹੈ! ਮੈਂ ਹਾਂ"", ਯੂਨਿਟੀ ਵਿੱਚ ਇੱਕ ਐਨੀਮੇਟਰ ਨੂੰ ਤਿਆਰ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਕੀ ਹੈ ਜੋ ਦੋ ਵੱਖ-ਵੱਖ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਿਟਾਂ ਲਈ ਇਕੱਠੇ ਕਰਦਾ ਹੈ। ', 'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ.', ' [\'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ ਸੀ #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nusingਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕ ਬੂਲ ਸਮਰੱਥ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਇਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕ ਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\nNAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਜੇਕਰ (Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਪ੍ਰੋਬੇਬਿਲਟੀ ਲਿਸਟ [Random.Range (0, probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawed; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ + transform.position; \\n ਇੰਸਟੈਂਟੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0,prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n {\\n ਨੰਮਸਪੌਨਡ + +; \\n} \\n ਜੇਕਰ (ਨੰਮਸਪੌਨਡ> = ਨੰਮਸਪੌਨਡ *ਸਪੌਨ ਇੰਟਰਵਲ) \\n {\\n ਜੇਕਰ (! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \\n} \\n} \\n "\'\\n ਇਹ ਸਕ੍ਰਿਪਟ ਤੁਹਾਨੂੰ ਸਪੌਨਰ ਨੂੰ ਸਮਰੱਥ/ਅਯੋਗ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਸੈੱਟ ਕਰੋਸਪੌਨਾਂ ਵਿਚਕਾਰ ਅੰਤਰਾਲ, ਨਾਮ _ 1 ਲਈ ਵਸਤੂਆਂ ਦੀ ਗਿਣਤੀ, ਅਤੇ ਸਪੌਨਰ ਦੇ ਆਲੇ ਦੁਆਲੇ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸ। ਇਸ ਵਿੱਚ ਇੱਕ ਪ੍ਰੀਫੈਬ ਵੀ ਹੁੰਦਾ ਹੈ।ਸੂਚੀ ਅਤੇ ਸੰਭਾਵਨਾ ਸੂਚੀ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਕਿ ਕੀ ਪੈਦਾ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਨਾਮ _ 1 ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ। ਸਕ੍ਰਿਪਟ ਇੱਕ ਫਾਰ ਲੂਪ ਨੂੰ ਨਾਮ _ 1 ਲਈ ਵਰਤਦੀ ਹੈ ਜਿਸ ਉੱਤੇ ਪ੍ਰੀਫੈਬ ਹੁੰਦੇ ਹਨ।ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ, ਅਤੇ ਸਿਰਫ ਨਾਮ _ 1 ਵਸਤੂਆਂ ਲਈ ਇੱਕ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੇ ਅੰਤਰਾਲ ਆਖਰੀ ਨਾਮ _ 1 ਤੋਂ ਲੰਘ ਗਿਆ ਹੈ।\',\' ਤੁਸੀਂ Input.GetKeyDown ਕਿਉਂ ਜੋਡ਼ਿਆ? \',\' ਮੈਂ ਅੱਪਡੇਟ () ਵਿਧੀ ਵਿੱਚ Input.GetKeyDown () ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਹੈ।ਸਪੇਸ ਬਾਰ ਦਬਾ ਕੇ ਉਪਭੋਗਤਾ ਨੂੰ ਨਾਮ _ 1 ਆਬਜੈਕਟ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ। ਇਹ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਜੇ ਨਹੀਂ ਤਾਂ ਇਸ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।\',\' ਜੇਕਰ ਕੋਈ ਪ੍ਰੀਫੈਬ ਇੰਸਟੈਂਸ਼ੀਏਟ ਨਹੀਂ ਹੈ ਤਾਂ ਨੰਮਸਪਾਨਡ ਇੰਕਰੀਮੈਂਟ ਕਿਉਂ ਹੁੰਦਾ ਹੈ। \',\' ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂਆਂ \'ਤੇ NAME _ 1 ਪ੍ਰੀਫੈਬ ਲਈ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਨਿਰਧਾਰਤ ਰੇਡੀਅਸ। ਲੂਪ ਸੰਭਾਵਨਾ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਰੈਂਡਮ ਇੰਡੈਕਸ ਦੀ ਚੋਣ ਕਰਨ ਲਈ Random.Range () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਬਣਾਉਣ ਲਈ ਇੰਸਟੈਂਸ਼ੀਏਟ () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਚੁਣੇ ਬਿੰਦੂ ਉੱਤੇ ਨਵਾਂ ਆਬਜੈਕਟ। ਜੇਕਰ ਚੁਣਿਆ ਇੰਡੈਕਸ 0 ਦੀ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਲੂਪ ਅਗਲੇ ਦੁਹਰਾਓ ਲਈ ਜਾਰੀ ਰਹੇਗਾ ਅਤੇ ਉਸ ਪ੍ਰੀਫੈਬ ਨੂੰ ਛੱਡ ਦੇਵੇਗਾ।ਹਾਲਾਂਕਿ, ਜੇਕਰ ਚੁਣਿਆ ਸੂਚਕਾਂਕ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਪ੍ਰੀਫੈਬ ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਉੱਤੇ ਪੈਦਾ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਜੇ ਨਹੀਂਪ੍ਰੀਫੈਬ ਦੀ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੁੰਦੀ ਹੈ, ਫਿਰ ਲੂਪ ਸਿਰਫ ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਨਾਵਾਂ ਵਾਲੇ ਪ੍ਰੀਫੈਬਾਂ ਨੂੰ ਨਾਮ _ 1 ਦੇਵੇਗਾ, ਅਤੇ ਨੰਮਸਪਾਨਡ ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਹੀਂਨਵੀਆਂ ਵਸਤੂਆਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹੋ \'numSpaund ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਾ ਕੀਤੀ ਗਈ ਹੋਵੇ।\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਅੱਪਡੇਟ ਕੀਤੀ ਸਕ੍ਰਿਪਟ ਹੈ।ਜੇਕਰ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਤਾਂ ਲਾਈਨ ਤੋਂ ਬਿਨਾਂ ਜੋ ਨੰਮਸ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈਃ \\n \'\\nਊਜ਼ਿੰਗ ਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕਬੂਲ ਇਨੇਬਲ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ(Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਸੰਭਾਵਨਾ ਸੂਚੀ [Random.Range (0,probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawnd; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ +transform.position; \\n ਇੰਸਟੈਂਸ਼ੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0, prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n{\\n numSpawned + +; \\n} \\n ਜੇਕਰ (numSpawned> = numSpawned * spawnInterval) \\n {\\n ਜੇਕਰ (! enableSpawner) \\n {\\n enable = false; \\n} \\n} \\n \',\' ਕੀ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ?ਮੈਨੂੰ ਹਟਾਈਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਵੇਖੋ? \',\' ਯਕੀਨਨ, ਇਹ ਉਹ ਲਾਈਨਾਂ ਹਨ ਜੋ ਹਟਾਈਆਂ ਗਈਆਂ ਸਨਃ \\n \'if (numSpawned> = numSpawned * spanInterval) \\n {\\n ਜੇਕਰ(! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \'\\n ਇਹ ਲਾਈਨਾਂ ਹਟਾ ਦਿੱਤੀਆਂ ਗਈਆਂ ਸਨ ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੀਆਂ ਸਨ ਅਤੇ ਇਹਨਾਂ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਵਿੱਚ ਯੋਗਦਾਨ ਨਹੀਂ ਪਾਉਂਦੀਆਂ ਸਨ।ਸਕ੍ਰਿਪਟ। \',\' ਤੁਹਾਨੂੰ ਧੰਨਵਾਦ, ਇਹ ਪਹਿਲੀ ਵਾਰ ਹੈ ਜਦੋਂ ਮੈਂ ਇੰਸਾਈਡਯੂਨਿਟਸਫੀਅਰ ਬਾਰੇ ਸੁਣਿਆ ਹੈ ਅਤੇ ਇਹ ਭਵਿੱਖ ਲਈ ਬਹੁਤ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ! \',\' ਤੁਹਾਡਾ ਸਵਾਗਤ ਹੈ! ਮੈਂ ਹਾਂਖੁਸ਼ੀ ਹੈ ਕਿ ਮੈਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ। "", ਯੂਨਿਟੀ ਵਿੱਚ ਇੱਕ ਐਨੀਮੇਟਰ ਨੂੰ ਤਿਆਰ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਕੀ ਹੈ ਜੋ ਦੋ ਵੱਖ-ਵੱਖ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਿਟਾਂ ਲਈ ਇਕੱਠੇ ਕਰਦਾ ਹੈ। ", \'ਜੇ ਤੁਸੀਂ ਮਦਦ ਕਰ ਸਕਦੇ ਹੋ।ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ ਲਈ ਦੋ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਿੰਕ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ ਹਰੇਕ ਸਪ੍ਰਾਈਟ ਲਈ ਇੱਕ ਨਵੀਂ ਪਰਤ ਬਣਾ ਸਕਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਪਰਤਾਂ ਨੂੰ ਐਨੀਮੇਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।ਫਿਰ, ਐਨੀਮੇਟਰ ਕੰਟਰੋਲਰ ਵਿੱਚ, ਤੁਸੀਂ ਦੋਵਾਂ ਲੇਅਰਾਂ ਨੂੰ ਇੱਕੋ ਐਨੀਮੇਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਮਕਾਲੀ ਕੀਤਾ ਜਾ ਸਕੇ। \',\' ਕੀ ਤੁਸੀਂ ਇੱਕ ਉਦਾਹਰਣ ਵਜੋਂ C #ਕੋਡ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹੋ? \' ', 'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ.', ' [\'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ ਸੀ #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nusingਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕ ਬੂਲ ਸਮਰੱਥ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਇਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕ ਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\nNAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਜੇਕਰ (Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਪ੍ਰੋਬੇਬਿਲਟੀ ਲਿਸਟ [Random.Range (0, probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawed; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ + transform.position; \\n ਇੰਸਟੈਂਟੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0,prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n {\\n ਨੰਮਸਪੌਨਡ + +; \\n} \\n ਜੇਕਰ (ਨੰਮਸਪੌਨਡ> = ਨੰਮਸਪੌਨਡ *ਸਪੌਨ ਇੰਟਰਵਲ) \\n {\\n ਜੇਕਰ (! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \\n} \\n} \\n "\'\\n ਇਹ ਸਕ੍ਰਿਪਟ ਤੁਹਾਨੂੰ ਸਪੌਨਰ ਨੂੰ ਸਮਰੱਥ/ਅਯੋਗ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਸੈੱਟ ਕਰੋਸਪੌਨਾਂ ਵਿਚਕਾਰ ਅੰਤਰਾਲ, ਨਾਮ _ 1 ਲਈ ਵਸਤੂਆਂ ਦੀ ਗਿਣਤੀ, ਅਤੇ ਸਪੌਨਰ ਦੇ ਆਲੇ ਦੁਆਲੇ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸ। ਇਸ ਵਿੱਚ ਇੱਕ ਪ੍ਰੀਫੈਬ ਵੀ ਹੁੰਦਾ ਹੈ।ਸੂਚੀ ਅਤੇ ਸੰਭਾਵਨਾ ਸੂਚੀ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਕਿ ਕੀ ਪੈਦਾ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਨਾਮ _ 1 ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ। ਸਕ੍ਰਿਪਟ ਇੱਕ ਫਾਰ ਲੂਪ ਨੂੰ ਨਾਮ _ 1 ਲਈ ਵਰਤਦੀ ਹੈ ਜਿਸ ਉੱਤੇ ਪ੍ਰੀਫੈਬ ਹੁੰਦੇ ਹਨ।ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ, ਅਤੇ ਸਿਰਫ ਨਾਮ _ 1 ਵਸਤੂਆਂ ਲਈ ਇੱਕ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੇ ਅੰਤਰਾਲ ਆਖਰੀ ਨਾਮ _ 1 ਤੋਂ ਲੰਘ ਗਿਆ ਹੈ।\',\' ਤੁਸੀਂ Input.GetKeyDown ਕਿਉਂ ਜੋਡ਼ਿਆ? \',\' ਮੈਂ ਅੱਪਡੇਟ () ਵਿਧੀ ਵਿੱਚ Input.GetKeyDown () ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਹੈ।ਸਪੇਸ ਬਾਰ ਦਬਾ ਕੇ ਉਪਭੋਗਤਾ ਨੂੰ ਨਾਮ _ 1 ਆਬਜੈਕਟ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ। ਇਹ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਜੇ ਨਹੀਂ ਤਾਂ ਇਸ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।\',\' ਜੇਕਰ ਕੋਈ ਪ੍ਰੀਫੈਬ ਇੰਸਟੈਂਸ਼ੀਏਟ ਨਹੀਂ ਹੈ ਤਾਂ ਨੰਮਸਪਾਨਡ ਇੰਕਰੀਮੈਂਟ ਕਿਉਂ ਹੁੰਦਾ ਹੈ। \',\' ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂਆਂ \'ਤੇ NAME _ 1 ਪ੍ਰੀਫੈਬ ਲਈ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਨਿਰਧਾਰਤ ਰੇਡੀਅਸ। ਲੂਪ ਸੰਭਾਵਨਾ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਰੈਂਡਮ ਇੰਡੈਕਸ ਦੀ ਚੋਣ ਕਰਨ ਲਈ Random.Range () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਬਣਾਉਣ ਲਈ ਇੰਸਟੈਂਸ਼ੀਏਟ () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਚੁਣੇ ਬਿੰਦੂ ਉੱਤੇ ਨਵਾਂ ਆਬਜੈਕਟ। ਜੇਕਰ ਚੁਣਿਆ ਇੰਡੈਕਸ 0 ਦੀ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਲੂਪ ਅਗਲੇ ਦੁਹਰਾਓ ਲਈ ਜਾਰੀ ਰਹੇਗਾ ਅਤੇ ਉਸ ਪ੍ਰੀਫੈਬ ਨੂੰ ਛੱਡ ਦੇਵੇਗਾ।ਹਾਲਾਂਕਿ, ਜੇਕਰ ਚੁਣਿਆ ਸੂਚਕਾਂਕ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਪ੍ਰੀਫੈਬ ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਉੱਤੇ ਪੈਦਾ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਜੇ ਨਹੀਂਪ੍ਰੀਫੈਬ ਦੀ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੁੰਦੀ ਹੈ, ਫਿਰ ਲੂਪ ਸਿਰਫ ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਨਾਵਾਂ ਵਾਲੇ ਪ੍ਰੀਫੈਬਾਂ ਨੂੰ ਨਾਮ _ 1 ਦੇਵੇਗਾ, ਅਤੇ ਨੰਮਸਪਾਨਡ ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਹੀਂਨਵੀਆਂ ਵਸਤੂਆਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹੋ \'numSpaund ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਾ ਕੀਤੀ ਗਈ ਹੋਵੇ।\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਅੱਪਡੇਟ ਕੀਤੀ ਸਕ੍ਰਿਪਟ ਹੈ।ਜੇਕਰ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਤਾਂ ਲਾਈਨ ਤੋਂ ਬਿਨਾਂ ਜੋ ਨੰਮਸ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈਃ \\n \'\\nਊਜ਼ਿੰਗ ਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕਬੂਲ ਇਨੇਬਲ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ(Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਸੰਭਾਵਨਾ ਸੂਚੀ [Random.Range (0,probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawnd; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ +transform.position; \\n ਇੰਸਟੈਂਸ਼ੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0, prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n{\\n numSpawned + +; \\n} \\n ਜੇਕਰ (numSpawned> = numSpawned * spawnInterval) \\n {\\n ਜੇਕਰ (! enableSpawner) \\n {\\n enable = false; \\n} \\n} \\n \',\' ਕੀ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ?ਮੈਨੂੰ ਹਟਾਈਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਵੇਖੋ? \',\' ਯਕੀਨਨ, ਇਹ ਉਹ ਲਾਈਨਾਂ ਹਨ ਜੋ ਹਟਾਈਆਂ ਗਈਆਂ ਸਨਃ \\n \'if (numSpawned> = numSpawned * spanInterval) \\n {\\n ਜੇਕਰ(! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \'\\n ਇਹ ਲਾਈਨਾਂ ਹਟਾ ਦਿੱਤੀਆਂ ਗਈਆਂ ਸਨ ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੀਆਂ ਸਨ ਅਤੇ ਇਹਨਾਂ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਵਿੱਚ ਯੋਗਦਾਨ ਨਹੀਂ ਪਾਉਂਦੀਆਂ ਸਨ।ਸਕ੍ਰਿਪਟ। \',\' ਤੁਹਾਨੂੰ ਧੰਨਵਾਦ, ਇਹ ਪਹਿਲੀ ਵਾਰ ਹੈ ਜਦੋਂ ਮੈਂ ਇੰਸਾਈਡਯੂਨਿਟਸਫੀਅਰ ਬਾਰੇ ਸੁਣਿਆ ਹੈ ਅਤੇ ਇਹ ਭਵਿੱਖ ਲਈ ਬਹੁਤ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ! \',\' ਤੁਹਾਡਾ ਸਵਾਗਤ ਹੈ! ਮੈਂ ਹਾਂਖੁਸ਼ੀ ਹੈ ਕਿ ਮੈਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ। "", ਯੂਨਿਟੀ ਵਿੱਚ ਇੱਕ ਐਨੀਮੇਟਰ ਨੂੰ ਤਿਆਰ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਕੀ ਹੈ ਜੋ ਦੋ ਵੱਖ-ਵੱਖ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਿਟਾਂ ਲਈ ਇਕੱਠੇ ਕਰਦਾ ਹੈ। ", \'ਜੇ ਤੁਸੀਂ ਮਦਦ ਕਰ ਸਕਦੇ ਹੋ।ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ ਲਈ ਦੋ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਿੰਕ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ ਹਰੇਕ ਸਪ੍ਰਾਈਟ ਲਈ ਇੱਕ ਨਵੀਂ ਪਰਤ ਬਣਾ ਸਕਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਪਰਤਾਂ ਨੂੰ ਐਨੀਮੇਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।ਫਿਰ, ਐਨੀਮੇਟਰ ਕੰਟਰੋਲਰ ਵਿੱਚ, ਤੁਸੀਂ ਦੋਵਾਂ ਲੇਅਰਾਂ ਨੂੰ ਇੱਕੋ ਐਨੀਮੇਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਮਕਾਲੀ ਕੀਤਾ ਜਾ ਸਕੇ। \',\' ਕੀ ਤੁਸੀਂ ਇੱਕ ਉਦਾਹਰਣ ਵਜੋਂ C #ਕੋਡ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹੋ? \',"ਯਕੀਨਨ, ਇੱਥੇ C #ਕੋਡ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ ਲਈ ਦੋ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਿੰਕ ਕਰਦੀ ਹੈਃ \\n \'\\nਊਜ਼ਿੰਗ ਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ।ਐਨੀਮੇਟਰ ਕੰਟਰੋਲਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ \\n {\\n ਪ੍ਰਾਈਵੇਟ ਐਨੀਮੇਟਰ ਐਨੀਮੇਟਰ; \\n ਪ੍ਰਾਈਵੇਟ ਸਪਰਾਈਟ ਰੈਂਡਰ ਸਪਰਾਈਟ ਰੈਂਡਰ1; \\n ਪ੍ਰਾਈਵੇਟ ਸਪਰਾਈਟ ਰੈਂਡਰspriteRenderer2; \\n// ਸਟਾਰਟ ਨੂੰ ਪਹਿਲੇ ਫਰੇਮ ਅੱਪਡੇਟ ਤੋਂ ਪਹਿਲਾਂ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ \\n ਵੋਇਡ ਸਟਾਰਟ () \\n {\\n ਐਨੀਮੇਟਰ = GetCਮ੍ਪੋਨੇਟ <ਐਨੀਮੇਟਰ> (); \\n spriteRenderer1 =GetComponent <SpriteRenderer> (); \\n spriteRenderer2 = GetComponent <SpriteRenderer> (); \\n} \\n ਪਬਲਿਕ ਵੋਇਡ ਸਿੰਕਐਨੀਮੇਸ਼ਨਜ਼ () \\n {\\nanimator.SetLayerWeight (0,1); \\n spriteRenderer1.enabled = ਗਲਤ; \\n spriteRenderer2.enabled = ਗਲਤ; \\n animator.SetLayerWeight (1,1); \\nspriteRenderer1.enabled = ਸੱਚ; \\n spriteRenderer2.enabled = ਸੱਚ; \\n} \\n} \\n "\'\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਦੋ ਲਈ ਐਨੀਮੇਟਰ ਕੰਪੋਨੈਂਟ ਅਤੇ ਸਪਰਾਈਟ ਰੈਂਡਰਰਸ ਮਿਲਦਾ ਹੈ।ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ। ਇਹ ਫਿਰ ਦੋ ਸਪ੍ਰਾਈਟ ਰੈਂਡਰਰਸ ਨੂੰ ਅਯੋਗ ਕਰ ਦਿੰਦਾ ਹੈ ਅਤੇ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਲਈ ਐਨੀਮੇਟਰ ਦੀ ਪਰਤ ਦਾ ਭਾਰ 1 ਸੈੱਟ ਕਰਦਾ ਹੈ। ਅੰਤ ਵਿੱਚ, ਇਹਸਪਰਾਈਟ ਰੈਂਡਰਰਜ਼ ਨੂੰ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਦੁਬਾਰਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ। ", \'ਇਹ ਕੰਪੋਨੈਂਟ ਕਿੱਥੇ ਮਾਊਂਟ ਹੁੰਦਾ ਹੈ?\' ', 'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ.', ' [\'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ ਸੀ #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nusingਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕ ਬੂਲ ਸਮਰੱਥ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਇਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕ ਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\nNAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਜੇਕਰ (Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਪ੍ਰੋਬੇਬਿਲਟੀ ਲਿਸਟ [Random.Range (0, probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawed; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ + transform.position; \\n ਇੰਸਟੈਂਟੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0,prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n {\\n ਨੰਮਸਪੌਨਡ + +; \\n} \\n ਜੇਕਰ (ਨੰਮਸਪੌਨਡ> = ਨੰਮਸਪੌਨਡ *ਸਪੌਨ ਇੰਟਰਵਲ) \\n {\\n ਜੇਕਰ (! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \\n} \\n} \\n "\'\\n ਇਹ ਸਕ੍ਰਿਪਟ ਤੁਹਾਨੂੰ ਸਪੌਨਰ ਨੂੰ ਸਮਰੱਥ/ਅਯੋਗ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਸੈੱਟ ਕਰੋਸਪੌਨਾਂ ਵਿਚਕਾਰ ਅੰਤਰਾਲ, ਨਾਮ _ 1 ਲਈ ਵਸਤੂਆਂ ਦੀ ਗਿਣਤੀ, ਅਤੇ ਸਪੌਨਰ ਦੇ ਆਲੇ ਦੁਆਲੇ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸ। ਇਸ ਵਿੱਚ ਇੱਕ ਪ੍ਰੀਫੈਬ ਵੀ ਹੁੰਦਾ ਹੈ।ਸੂਚੀ ਅਤੇ ਸੰਭਾਵਨਾ ਸੂਚੀ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਕਿ ਕੀ ਪੈਦਾ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਨਾਮ _ 1 ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ। ਸਕ੍ਰਿਪਟ ਇੱਕ ਫਾਰ ਲੂਪ ਨੂੰ ਨਾਮ _ 1 ਲਈ ਵਰਤਦੀ ਹੈ ਜਿਸ ਉੱਤੇ ਪ੍ਰੀਫੈਬ ਹੁੰਦੇ ਹਨ।ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ, ਅਤੇ ਸਿਰਫ ਨਾਮ _ 1 ਵਸਤੂਆਂ ਲਈ ਇੱਕ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੇ ਅੰਤਰਾਲ ਆਖਰੀ ਨਾਮ _ 1 ਤੋਂ ਲੰਘ ਗਿਆ ਹੈ।\',\' ਤੁਸੀਂ Input.GetKeyDown ਕਿਉਂ ਜੋਡ਼ਿਆ? \',\' ਮੈਂ ਅੱਪਡੇਟ () ਵਿਧੀ ਵਿੱਚ Input.GetKeyDown () ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਹੈ।ਸਪੇਸ ਬਾਰ ਦਬਾ ਕੇ ਉਪਭੋਗਤਾ ਨੂੰ ਨਾਮ _ 1 ਆਬਜੈਕਟ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ। ਇਹ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਜੇ ਨਹੀਂ ਤਾਂ ਇਸ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।\',\' ਜੇਕਰ ਕੋਈ ਪ੍ਰੀਫੈਬ ਇੰਸਟੈਂਸ਼ੀਏਟ ਨਹੀਂ ਹੈ ਤਾਂ ਨੰਮਸਪਾਨਡ ਇੰਕਰੀਮੈਂਟ ਕਿਉਂ ਹੁੰਦਾ ਹੈ। \',\' ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂਆਂ \'ਤੇ NAME _ 1 ਪ੍ਰੀਫੈਬ ਲਈ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਨਿਰਧਾਰਤ ਰੇਡੀਅਸ। ਲੂਪ ਸੰਭਾਵਨਾ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਰੈਂਡਮ ਇੰਡੈਕਸ ਦੀ ਚੋਣ ਕਰਨ ਲਈ Random.Range () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਬਣਾਉਣ ਲਈ ਇੰਸਟੈਂਸ਼ੀਏਟ () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਚੁਣੇ ਬਿੰਦੂ ਉੱਤੇ ਨਵਾਂ ਆਬਜੈਕਟ। ਜੇਕਰ ਚੁਣਿਆ ਇੰਡੈਕਸ 0 ਦੀ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਲੂਪ ਅਗਲੇ ਦੁਹਰਾਓ ਲਈ ਜਾਰੀ ਰਹੇਗਾ ਅਤੇ ਉਸ ਪ੍ਰੀਫੈਬ ਨੂੰ ਛੱਡ ਦੇਵੇਗਾ।ਹਾਲਾਂਕਿ, ਜੇਕਰ ਚੁਣਿਆ ਸੂਚਕਾਂਕ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਪ੍ਰੀਫੈਬ ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਉੱਤੇ ਪੈਦਾ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਜੇ ਨਹੀਂਪ੍ਰੀਫੈਬ ਦੀ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੁੰਦੀ ਹੈ, ਫਿਰ ਲੂਪ ਸਿਰਫ ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਨਾਵਾਂ ਵਾਲੇ ਪ੍ਰੀਫੈਬਾਂ ਨੂੰ ਨਾਮ _ 1 ਦੇਵੇਗਾ, ਅਤੇ ਨੰਮਸਪਾਨਡ ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਹੀਂਨਵੀਆਂ ਵਸਤੂਆਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹੋ \'numSpaund ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਾ ਕੀਤੀ ਗਈ ਹੋਵੇ।\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਅੱਪਡੇਟ ਕੀਤੀ ਸਕ੍ਰਿਪਟ ਹੈ।ਜੇਕਰ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਤਾਂ ਲਾਈਨ ਤੋਂ ਬਿਨਾਂ ਜੋ ਨੰਮਸ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈਃ \\n \'\\nਊਜ਼ਿੰਗ ਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕਬੂਲ ਇਨੇਬਲ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ(Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਸੰਭਾਵਨਾ ਸੂਚੀ [Random.Range (0,probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawnd; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ +transform.position; \\n ਇੰਸਟੈਂਸ਼ੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0, prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n{\\n numSpawned + +; \\n} \\n ਜੇਕਰ (numSpawned> = numSpawned * spawnInterval) \\n {\\n ਜੇਕਰ (! enableSpawner) \\n {\\n enable = false; \\n} \\n} \\n \',\' ਕੀ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ?ਮੈਨੂੰ ਹਟਾਈਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਵੇਖੋ? \',\' ਯਕੀਨਨ, ਇਹ ਉਹ ਲਾਈਨਾਂ ਹਨ ਜੋ ਹਟਾਈਆਂ ਗਈਆਂ ਸਨਃ \\n \'if (numSpawned> = numSpawned * spanInterval) \\n {\\n ਜੇਕਰ(! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \'\\n ਇਹ ਲਾਈਨਾਂ ਹਟਾ ਦਿੱਤੀਆਂ ਗਈਆਂ ਸਨ ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੀਆਂ ਸਨ ਅਤੇ ਇਹਨਾਂ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਵਿੱਚ ਯੋਗਦਾਨ ਨਹੀਂ ਪਾਉਂਦੀਆਂ ਸਨ।ਸਕ੍ਰਿਪਟ। \',\' ਤੁਹਾਨੂੰ ਧੰਨਵਾਦ, ਇਹ ਪਹਿਲੀ ਵਾਰ ਹੈ ਜਦੋਂ ਮੈਂ ਇੰਸਾਈਡਯੂਨਿਟਸਫੀਅਰ ਬਾਰੇ ਸੁਣਿਆ ਹੈ ਅਤੇ ਇਹ ਭਵਿੱਖ ਲਈ ਬਹੁਤ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ! \',\' ਤੁਹਾਡਾ ਸਵਾਗਤ ਹੈ! ਮੈਂ ਹਾਂਖੁਸ਼ੀ ਹੈ ਕਿ ਮੈਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ। "", ਯੂਨਿਟੀ ਵਿੱਚ ਇੱਕ ਐਨੀਮੇਟਰ ਨੂੰ ਤਿਆਰ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਕੀ ਹੈ ਜੋ ਦੋ ਵੱਖ-ਵੱਖ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਿਟਾਂ ਲਈ ਇਕੱਠੇ ਕਰਦਾ ਹੈ। ", \'ਜੇ ਤੁਸੀਂ ਮਦਦ ਕਰ ਸਕਦੇ ਹੋ।ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ ਲਈ ਦੋ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਿੰਕ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ ਹਰੇਕ ਸਪ੍ਰਾਈਟ ਲਈ ਇੱਕ ਨਵੀਂ ਪਰਤ ਬਣਾ ਸਕਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਪਰਤਾਂ ਨੂੰ ਐਨੀਮੇਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।ਫਿਰ, ਐਨੀਮੇਟਰ ਕੰਟਰੋਲਰ ਵਿੱਚ, ਤੁਸੀਂ ਦੋਵਾਂ ਲੇਅਰਾਂ ਨੂੰ ਇੱਕੋ ਐਨੀਮੇਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਮਕਾਲੀ ਕੀਤਾ ਜਾ ਸਕੇ। \',\' ਕੀ ਤੁਸੀਂ ਇੱਕ ਉਦਾਹਰਣ ਵਜੋਂ C #ਕੋਡ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹੋ? \',"ਯਕੀਨਨ, ਇੱਥੇ C #ਕੋਡ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ ਲਈ ਦੋ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਿੰਕ ਕਰਦੀ ਹੈਃ \\n \'\\nਊਜ਼ਿੰਗ ਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ।ਐਨੀਮੇਟਰ ਕੰਟਰੋਲਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ \\n {\\n ਪ੍ਰਾਈਵੇਟ ਐਨੀਮੇਟਰ ਐਨੀਮੇਟਰ; \\n ਪ੍ਰਾਈਵੇਟ ਸਪਰਾਈਟ ਰੈਂਡਰ ਸਪਰਾਈਟ ਰੈਂਡਰ1; \\n ਪ੍ਰਾਈਵੇਟ ਸਪਰਾਈਟ ਰੈਂਡਰspriteRenderer2; \\n// ਸਟਾਰਟ ਨੂੰ ਪਹਿਲੇ ਫਰੇਮ ਅੱਪਡੇਟ ਤੋਂ ਪਹਿਲਾਂ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ \\n ਵੋਇਡ ਸਟਾਰਟ () \\n {\\n ਐਨੀਮੇਟਰ = GetCਮ੍ਪੋਨੇਟ <ਐਨੀਮੇਟਰ> (); \\n spriteRenderer1 =GetComponent <SpriteRenderer> (); \\n spriteRenderer2 = GetComponent <SpriteRenderer> (); \\n} \\n ਪਬਲਿਕ ਵੋਇਡ ਸਿੰਕਐਨੀਮੇਸ਼ਨਜ਼ () \\n {\\nanimator.SetLayerWeight (0,1); \\n spriteRenderer1.enabled = ਗਲਤ; \\n spriteRenderer2.enabled = ਗਲਤ; \\n animator.SetLayerWeight (1,1); \\nspriteRenderer1.enabled = ਸੱਚ; \\n spriteRenderer2.enabled = ਸੱਚ; \\n} \\n} \\n "\'\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਦੋ ਲਈ ਐਨੀਮੇਟਰ ਕੰਪੋਨੈਂਟ ਅਤੇ ਸਪਰਾਈਟ ਰੈਂਡਰਰਸ ਮਿਲਦਾ ਹੈ।ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ। ਇਹ ਫਿਰ ਦੋ ਸਪ੍ਰਾਈਟ ਰੈਂਡਰਰਸ ਨੂੰ ਅਯੋਗ ਕਰ ਦਿੰਦਾ ਹੈ ਅਤੇ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਲਈ ਐਨੀਮੇਟਰ ਦੀ ਪਰਤ ਦਾ ਭਾਰ 1 ਸੈੱਟ ਕਰਦਾ ਹੈ। ਅੰਤ ਵਿੱਚ, ਇਹਸਪਰਾਈਟ ਰੈਂਡਰਰਸ ਨੂੰ ਐਨੀਮੇਸ਼ਨ ਦਿਖਾਉਣ ਲਈ ਮੁਡ਼ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ। ", \'ਇਹ ਕੰਪੋਨੈਂਟ ਕਿੱਥੇ ਮਾਊਂਟ ਹੁੰਦਾ ਹੈ?\', \'ਇਸ ਕੰਪੋਨੈਂਟ ਨੂੰ ਕਿਸੇ ਵੀ ਗੇਮ ਆਬਜੈਕਟ ਉੱਤੇ ਮਾਊਂਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਜਿਸ ਵਿੱਚ ਇੱਕ ਐਨੀਮੇਟਰ ਕੰਪੋਨੈਂਟ ਹੈ। \',\' ਮੈਂ ਸੀਨ ਵਿੱਚ ਸਪ੍ਰਿਟਸ ਦੇ ਇੱਕ ਵੱਡੇ ਪੂਲ ਵਿੱਚੋਂ ਸਹੀ ਸਪ੍ਰਿਟਸ ਦੀ ਚੋਣ ਕਿਵੇਂ ਕਰਾਂ? \' ', 'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ.', ' [\'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ ਸੀ #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nusingਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕ ਬੂਲ ਸਮਰੱਥ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਇਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕ ਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\nNAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਜੇਕਰ (Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਪ੍ਰੋਬੇਬਿਲਟੀ ਲਿਸਟ [Random.Range (0, probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawed; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ + transform.position; \\n ਇੰਸਟੈਂਟੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0,prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n {\\n ਨੰਮਸਪੌਨਡ + +; \\n} \\n ਜੇਕਰ (ਨੰਮਸਪੌਨਡ> = ਨੰਮਸਪੌਨਡ *ਸਪੌਨ ਇੰਟਰਵਲ) \\n {\\n ਜੇਕਰ (! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \\n} \\n} \\n "\'\\n ਇਹ ਸਕ੍ਰਿਪਟ ਤੁਹਾਨੂੰ ਸਪੌਨਰ ਨੂੰ ਸਮਰੱਥ/ਅਯੋਗ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਸੈੱਟ ਕਰੋਸਪੌਨਾਂ ਵਿਚਕਾਰ ਅੰਤਰਾਲ, ਨਾਮ _ 1 ਲਈ ਵਸਤੂਆਂ ਦੀ ਗਿਣਤੀ, ਅਤੇ ਸਪੌਨਰ ਦੇ ਆਲੇ ਦੁਆਲੇ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸ। ਇਸ ਵਿੱਚ ਇੱਕ ਪ੍ਰੀਫੈਬ ਵੀ ਹੁੰਦਾ ਹੈ।ਸੂਚੀ ਅਤੇ ਸੰਭਾਵਨਾ ਸੂਚੀ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਕਿ ਕੀ ਪੈਦਾ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਨਾਮ _ 1 ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ। ਸਕ੍ਰਿਪਟ ਇੱਕ ਫਾਰ ਲੂਪ ਨੂੰ ਨਾਮ _ 1 ਲਈ ਵਰਤਦੀ ਹੈ ਜਿਸ ਉੱਤੇ ਪ੍ਰੀਫੈਬ ਹੁੰਦੇ ਹਨ।ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ, ਅਤੇ ਸਿਰਫ ਨਾਮ _ 1 ਵਸਤੂਆਂ ਲਈ ਇੱਕ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੇ ਅੰਤਰਾਲ ਆਖਰੀ ਨਾਮ _ 1 ਤੋਂ ਲੰਘ ਗਿਆ ਹੈ।\',\' ਤੁਸੀਂ Input.GetKeyDown ਕਿਉਂ ਜੋਡ਼ਿਆ? \',\' ਮੈਂ ਅੱਪਡੇਟ () ਵਿਧੀ ਵਿੱਚ Input.GetKeyDown () ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਹੈ।ਸਪੇਸ ਬਾਰ ਦਬਾ ਕੇ ਉਪਭੋਗਤਾ ਨੂੰ ਨਾਮ _ 1 ਆਬਜੈਕਟ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ। ਇਹ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਜੇ ਨਹੀਂ ਤਾਂ ਇਸ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।\',\' ਜੇਕਰ ਕੋਈ ਪ੍ਰੀਫੈਬ ਇੰਸਟੈਂਸ਼ੀਏਟ ਨਹੀਂ ਹੈ ਤਾਂ ਨੰਮਸਪਾਨਡ ਇੰਕਰੀਮੈਂਟ ਕਿਉਂ ਹੁੰਦਾ ਹੈ। \',\' ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂਆਂ \'ਤੇ NAME _ 1 ਪ੍ਰੀਫੈਬ ਲਈ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਨਿਰਧਾਰਤ ਰੇਡੀਅਸ। ਲੂਪ ਸੰਭਾਵਨਾ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਰੈਂਡਮ ਇੰਡੈਕਸ ਦੀ ਚੋਣ ਕਰਨ ਲਈ Random.Range () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਬਣਾਉਣ ਲਈ ਇੰਸਟੈਂਸ਼ੀਏਟ () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਚੁਣੇ ਬਿੰਦੂ ਉੱਤੇ ਨਵਾਂ ਆਬਜੈਕਟ। ਜੇਕਰ ਚੁਣਿਆ ਇੰਡੈਕਸ 0 ਦੀ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਲੂਪ ਅਗਲੇ ਦੁਹਰਾਓ ਲਈ ਜਾਰੀ ਰਹੇਗਾ ਅਤੇ ਉਸ ਪ੍ਰੀਫੈਬ ਨੂੰ ਛੱਡ ਦੇਵੇਗਾ।ਹਾਲਾਂਕਿ, ਜੇਕਰ ਚੁਣਿਆ ਸੂਚਕਾਂਕ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਪ੍ਰੀਫੈਬ ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਉੱਤੇ ਪੈਦਾ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਜੇ ਨਹੀਂਪ੍ਰੀਫੈਬ ਦੀ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੁੰਦੀ ਹੈ, ਫਿਰ ਲੂਪ ਸਿਰਫ ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਨਾਵਾਂ ਵਾਲੇ ਪ੍ਰੀਫੈਬਾਂ ਨੂੰ ਨਾਮ _ 1 ਦੇਵੇਗਾ, ਅਤੇ ਨੰਮਸਪਾਨਡ ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਹੀਂਨਵੀਆਂ ਵਸਤੂਆਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹੋ \'numSpaund ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਾ ਕੀਤੀ ਗਈ ਹੋਵੇ।\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਅੱਪਡੇਟ ਕੀਤੀ ਸਕ੍ਰਿਪਟ ਹੈ।ਜੇਕਰ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਤਾਂ ਲਾਈਨ ਤੋਂ ਬਿਨਾਂ ਜੋ ਨੰਮਸ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈਃ \\n \'\\nਊਜ਼ਿੰਗ ਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕਬੂਲ ਇਨੇਬਲ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ(Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਸੰਭਾਵਨਾ ਸੂਚੀ [Random.Range (0,probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawnd; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ +transform.position; \\n ਇੰਸਟੈਂਸ਼ੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0, prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n{\\n numSpawned + +; \\n} \\n ਜੇਕਰ (numSpawned> = numSpawned * spawnInterval) \\n {\\n ਜੇਕਰ (! enableSpawner) \\n {\\n enable = false; \\n} \\n} \\n \',\' ਕੀ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ?ਮੈਨੂੰ ਹਟਾਈਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਵੇਖੋ? \',\' ਯਕੀਨਨ, ਇਹ ਉਹ ਲਾਈਨਾਂ ਹਨ ਜੋ ਹਟਾਈਆਂ ਗਈਆਂ ਸਨਃ \\n \'if (numSpawned> = numSpawned * spanInterval) \\n {\\n ਜੇਕਰ(! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \'\\n ਇਹ ਲਾਈਨਾਂ ਹਟਾ ਦਿੱਤੀਆਂ ਗਈਆਂ ਸਨ ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੀਆਂ ਸਨ ਅਤੇ ਇਹਨਾਂ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਵਿੱਚ ਯੋਗਦਾਨ ਨਹੀਂ ਪਾਉਂਦੀਆਂ ਸਨ।ਸਕ੍ਰਿਪਟ। \',\' ਤੁਹਾਨੂੰ ਧੰਨਵਾਦ, ਇਹ ਪਹਿਲੀ ਵਾਰ ਹੈ ਜਦੋਂ ਮੈਂ ਇੰਸਾਈਡਯੂਨਿਟਸਫੀਅਰ ਬਾਰੇ ਸੁਣਿਆ ਹੈ ਅਤੇ ਇਹ ਭਵਿੱਖ ਲਈ ਬਹੁਤ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ! \',\' ਤੁਹਾਡਾ ਸਵਾਗਤ ਹੈ! ਮੈਂ ਹਾਂਖੁਸ਼ੀ ਹੈ ਕਿ ਮੈਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ। "", ਯੂਨਿਟੀ ਵਿੱਚ ਇੱਕ ਐਨੀਮੇਟਰ ਨੂੰ ਤਿਆਰ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਕੀ ਹੈ ਜੋ ਦੋ ਵੱਖ-ਵੱਖ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਿਟਾਂ ਲਈ ਇਕੱਠੇ ਕਰਦਾ ਹੈ। ", \'ਜੇ ਤੁਸੀਂ ਮਦਦ ਕਰ ਸਕਦੇ ਹੋ।ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ ਲਈ ਦੋ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਿੰਕ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ ਹਰੇਕ ਸਪ੍ਰਾਈਟ ਲਈ ਇੱਕ ਨਵੀਂ ਪਰਤ ਬਣਾ ਸਕਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਪਰਤਾਂ ਨੂੰ ਐਨੀਮੇਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।ਫਿਰ, ਐਨੀਮੇਟਰ ਕੰਟਰੋਲਰ ਵਿੱਚ, ਤੁਸੀਂ ਦੋਵਾਂ ਲੇਅਰਾਂ ਨੂੰ ਇੱਕੋ ਐਨੀਮੇਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਮਕਾਲੀ ਕੀਤਾ ਜਾ ਸਕੇ। \',\' ਕੀ ਤੁਸੀਂ ਇੱਕ ਉਦਾਹਰਣ ਵਜੋਂ C #ਕੋਡ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹੋ? \',"ਯਕੀਨਨ, ਇੱਥੇ C #ਕੋਡ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ ਲਈ ਦੋ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਿੰਕ ਕਰਦੀ ਹੈਃ \\n \'\\nਊਜ਼ਿੰਗ ਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ।ਐਨੀਮੇਟਰ ਕੰਟਰੋਲਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ \\n {\\n ਪ੍ਰਾਈਵੇਟ ਐਨੀਮੇਟਰ ਐਨੀਮੇਟਰ; \\n ਪ੍ਰਾਈਵੇਟ ਸਪਰਾਈਟ ਰੈਂਡਰ ਸਪਰਾਈਟ ਰੈਂਡਰ1; \\n ਪ੍ਰਾਈਵੇਟ ਸਪਰਾਈਟ ਰੈਂਡਰspriteRenderer2; \\n// ਸਟਾਰਟ ਨੂੰ ਪਹਿਲੇ ਫਰੇਮ ਅੱਪਡੇਟ ਤੋਂ ਪਹਿਲਾਂ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ \\n ਵੋਇਡ ਸਟਾਰਟ () \\n {\\n ਐਨੀਮੇਟਰ = GetCਮ੍ਪੋਨੇਟ <ਐਨੀਮੇਟਰ> (); \\n spriteRenderer1 =GetComponent <SpriteRenderer> (); \\n spriteRenderer2 = GetComponent <SpriteRenderer> (); \\n} \\n ਪਬਲਿਕ ਵੋਇਡ ਸਿੰਕਐਨੀਮੇਸ਼ਨਜ਼ () \\n {\\nanimator.SetLayerWeight (0,1); \\n spriteRenderer1.enabled = ਗਲਤ; \\n spriteRenderer2.enabled = ਗਲਤ; \\n animator.SetLayerWeight (1,1); \\nspriteRenderer1.enabled = ਸੱਚ; \\n spriteRenderer2.enabled = ਸੱਚ; \\n} \\n} \\n "\'\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਦੋ ਲਈ ਐਨੀਮੇਟਰ ਕੰਪੋਨੈਂਟ ਅਤੇ ਸਪਰਾਈਟ ਰੈਂਡਰਰਸ ਮਿਲਦਾ ਹੈ।ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ। ਇਹ ਫਿਰ ਦੋ ਸਪ੍ਰਾਈਟ ਰੈਂਡਰਰਸ ਨੂੰ ਅਯੋਗ ਕਰ ਦਿੰਦਾ ਹੈ ਅਤੇ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਲਈ ਐਨੀਮੇਟਰ ਦੀ ਪਰਤ ਦਾ ਭਾਰ 1 ਸੈੱਟ ਕਰਦਾ ਹੈ। ਅੰਤ ਵਿੱਚ, ਇਹਸਪਰਾਈਟ ਰੈਂਡਰਰਸ ਨੂੰ ਐਨੀਮੇਸ਼ਨ ਦਿਖਾਉਣ ਲਈ ਮੁਡ਼ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ। ", \'ਇਹ ਕੰਪੋਨੈਂਟ ਕਿੱਥੇ ਮਾਊਂਟ ਹੁੰਦਾ ਹੈ?\', \'ਇਸ ਕੰਪੋਨੈਂਟ ਨੂੰ ਕਿਸੇ ਵੀ ਗੇਮ ਆਬਜੈਕਟ ਉੱਤੇ ਮਾਊਂਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਜਿਸ ਵਿੱਚ ਇੱਕ ਐਨੀਮੇਟਰ ਕੰਪੋਨੈਂਟ ਹੈ। \',\' ਮੈਂ ਸੀਨ ਵਿੱਚ ਸਪਰਾਈਟਸ ਦੇ ਇੱਕ ਵੱਡੇ ਪੂਲ ਵਿੱਚੋਂ ਸਹੀ ਸਪਰਾਈਟਸ ਦੀ ਚੋਣ ਕਿਵੇਂ ਕਰਾਂ? \',\' ਤੁਸੀਂ ਇੱਕ ਖਾਸ ਸਪਰਾਈਟ ਦੀ ਚੋਣ ਕਰ ਸਕਦੇ ਹੋ।ਇਸ ਦੇ ਨਾਮ ਜਾਂ ਟੈਗ ਦੁਆਰਾ। ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਸੀਨ ਵਿੱਚ ਸਪਰਾਈਟਸ ਦਾ ਇੱਕ ਵੱਡਾ ਪੂਲ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਹਰੇਕ ਸਪਰਾਈਟ ਰਾਹੀਂ ਦੁਹਰਾਉਣ ਲਈ ਇੱਕ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸ ਦੇ ਨਾਮ ਜਾਂ ਟੈਗ ਦੀ ਤੁਲਨਾ ਕਰ ਸਕਦੇ ਹੋ।ਇੱਕ ਖਾਸ ਮੁੱਲ ਨੂੰ ਟੈਗ ਕਰੋ। ਇੱਥੇ C #ਕੋਡ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਇੱਕ ਖਾਸ ਸਪਰਾਈਟ ਦੀ ਚੋਣ ਕਰਦੀ ਹੈਃ \\n "\'\\nusing UnityEngine; \\npublick class SpriteSlector:ਮੋਨੋਬਿਹੇਵੀਅਰ \\n {\\n ਪਬਲਿਕ ਸਟਰਿੰਗ ਸਪਰਾਈਟਨਾਮ; \\n ਪਬਲਿਕ ਸਟਰਿੰਗ ਟੈਗ; \\n ਪ੍ਰਾਈਵੇਟ ਸਪਰਾਈਟ ਰੈਂਡਰ ਸਪਰਾਈਟ ਰੈਂਡਰ; \\n// ਸਟਾਰਟ ਨੂੰ ਪਹਿਲੇ ਫਰੇਮ ਤੋਂ ਪਹਿਲਾਂ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਅੱਪਡੇਟ \\n ਵੋਇਡ ਸਟਾਰਟ () \\n {\\n ਸਪਰਾਈਟ ਰੈਂਡਰਰ = ਗੇਟ ਕੰਪੋਨੈਂਟ <ਸਪਰਾਈਟ ਰੈਂਡਰਰ> (); \\n} \\n ਪਬਲਿਕ ਵੋਇਡ ਚੁਣੋ ਸਪਰਾਈਟ () \\n {\\n ਫੋਰੈਚ (ਸਪਰਾਈਟ ਰੈਂਡਰਰ ਸਪਰਾਈਟ ਇਨਲੱਭੋ ਆਬਜੈਕਟਸਓਫ ਟਾਈਪ <ਸਪ੍ਰਾਈਟ ਰੈਂਡਰਰ> ()) \\n {\\n ਜੇਕਰ (sprite.name = = ਸਪ੍ਰਾਈਟਨਾਮ।। sprite.tag = = ਟੈਗ) \\n {\\n spriteRenderer.enabled = ਸੱਚ; \\n ਬਰੇਕ; \\n} \\nਨਹੀਂ ਤਾਂ \\n {\\n ਜਾਰੀ ਹੈ; \\n} \\n} \\n} \\n "\\n" ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਪ੍ਰਾਈਟ ਰੈਂਡਰਰ ਕੰਪੋਨੈਂਟ ਮਿਲਦਾ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਸਾਰੇ ਸਪ੍ਰਾਈਟ ਰੈਂਡਰਸ ਰਾਹੀਂ ਦੁਹਰਾਉਣ ਲਈ ਇੱਕ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਦ੍ਰਿਸ਼। ਹਰੇਕ ਸਪਰਾਈਟ ਰੈਂਡਰ ਲਈ, ਇਹ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਇਸ ਦਾ ਨਾਮ ਜਾਂ ਟੈਗ ਨਿਰਧਾਰਤ ਮੁੱਲ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਜੇ ਕੋਈ ਮੇਲ ਮਿਲਦਾ ਹੈ, ਤਾਂ ਇਹ ਸਪਰਾਈਟ ਰੈਂਡਰ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ।ਪਹਿਲਾਂ ਇੱਕ ਸੈੱਟ ਲੇਅਰ ਵੇਟ ਕੀ ਹੁੰਦਾ ਹੈ? \'] ', 'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ.', ' [\'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ ਸੀ #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ। \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nusingਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕ ਬੂਲ ਸਮਰੱਥ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਇਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕ ਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\nNAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਜੇਕਰ (Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਪ੍ਰੋਬੇਬਿਲਟੀ ਲਿਸਟ [Random.Range (0, probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawed; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ + transform.position; \\n ਇੰਸਟੈਂਟੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0,prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n {\\n ਨੰਮਸਪੌਨਡ + +; \\n} \\n ਜੇਕਰ (ਨੰਮਸਪੌਨਡ> = ਨੰਮਸਪੌਨਡ *ਸਪੌਨ ਇੰਟਰਵਲ) \\n {\\n ਜੇਕਰ (! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \\n} \\n} \\n "\'\\n ਇਹ ਸਕ੍ਰਿਪਟ ਤੁਹਾਨੂੰ ਸਪੌਨਰ ਨੂੰ ਸਮਰੱਥ/ਅਯੋਗ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਸੈੱਟ ਕਰੋਸਪੌਨਾਂ ਵਿਚਕਾਰ ਅੰਤਰਾਲ, ਨਾਮ _ 1 ਲਈ ਵਸਤੂਆਂ ਦੀ ਗਿਣਤੀ, ਅਤੇ ਸਪੌਨਰ ਦੇ ਆਲੇ ਦੁਆਲੇ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸ। ਇਸ ਵਿੱਚ ਇੱਕ ਪ੍ਰੀਫੈਬ ਵੀ ਹੁੰਦਾ ਹੈ।ਸੂਚੀ ਅਤੇ ਸੰਭਾਵਨਾ ਸੂਚੀ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਕਿ ਕੀ ਪੈਦਾ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਨਾਮ _ 1 ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰਨ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ। ਸਕ੍ਰਿਪਟ ਇੱਕ ਫਾਰ ਲੂਪ ਨੂੰ ਨਾਮ _ 1 ਲਈ ਵਰਤਦੀ ਹੈ ਜਿਸ ਉੱਤੇ ਪ੍ਰੀਫੈਬ ਹੁੰਦੇ ਹਨ।ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ, ਅਤੇ ਸਿਰਫ ਨਾਮ _ 1 ਵਸਤੂਆਂ ਲਈ ਇੱਕ ਵਾਇਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜੇ ਅੰਤਰਾਲ ਆਖਰੀ ਨਾਮ _ 1 ਤੋਂ ਲੰਘ ਗਿਆ ਹੈ।\',\' ਤੁਸੀਂ Input.GetKeyDown ਕਿਉਂ ਜੋਡ਼ਿਆ? \',\' ਮੈਂ ਅੱਪਡੇਟ () ਵਿਧੀ ਵਿੱਚ Input.GetKeyDown () ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਹੈ।ਸਪੇਸ ਬਾਰ ਦਬਾ ਕੇ ਉਪਭੋਗਤਾ ਨੂੰ ਨਾਮ _ 1 ਆਬਜੈਕਟ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ। ਇਹ ਟੈਸਟਿੰਗ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਜੇ ਨਹੀਂ ਤਾਂ ਇਸ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।\',\' ਜੇਕਰ ਕੋਈ ਪ੍ਰੀਫੈਬ ਇੰਸਟੈਂਸ਼ੀਏਟ ਨਹੀਂ ਹੈ ਤਾਂ ਨੰਮਸਪਾਨਡ ਇੰਕਰੀਮੈਂਟ ਕਿਉਂ ਹੁੰਦਾ ਹੈ। \',\' ਸਕ੍ਰਿਪਟ ਦੇ ਅੰਦਰ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂਆਂ \'ਤੇ NAME _ 1 ਪ੍ਰੀਫੈਬ ਲਈ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਨਿਰਧਾਰਤ ਰੇਡੀਅਸ। ਲੂਪ ਸੰਭਾਵਨਾ ਸੂਚੀ ਵਿੱਚੋਂ ਇੱਕ ਰੈਂਡਮ ਇੰਡੈਕਸ ਦੀ ਚੋਣ ਕਰਨ ਲਈ Random.Range () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਬਣਾਉਣ ਲਈ ਇੰਸਟੈਂਸ਼ੀਏਟ () ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਚੁਣੇ ਬਿੰਦੂ ਉੱਤੇ ਨਵਾਂ ਆਬਜੈਕਟ। ਜੇਕਰ ਚੁਣਿਆ ਇੰਡੈਕਸ 0 ਦੀ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਲੂਪ ਅਗਲੇ ਦੁਹਰਾਓ ਲਈ ਜਾਰੀ ਰਹੇਗਾ ਅਤੇ ਉਸ ਪ੍ਰੀਫੈਬ ਨੂੰ ਛੱਡ ਦੇਵੇਗਾ।ਹਾਲਾਂਕਿ, ਜੇਕਰ ਚੁਣਿਆ ਸੂਚਕਾਂਕ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੈ, ਤਾਂ ਪ੍ਰੀਫੈਬ ਨਿਰਧਾਰਤ ਘੇਰੇ ਦੇ ਅੰਦਰ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਉੱਤੇ ਪੈਦਾ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਜੇ ਨਹੀਂਪ੍ਰੀਫੈਬ ਦੀ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਸੰਭਾਵਨਾ ਹੁੰਦੀ ਹੈ, ਫਿਰ ਲੂਪ ਸਿਰਫ ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਨਾਵਾਂ ਵਾਲੇ ਪ੍ਰੀਫੈਬਾਂ ਨੂੰ ਨਾਮ _ 1 ਦੇਵੇਗਾ, ਅਤੇ ਨੰਮਸਪਾਨਡ ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਹੀਂਨਵੀਆਂ ਵਸਤੂਆਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ। \',\' ਕੀ ਤੁਸੀਂ ਇਸ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹੋ \'numSpaund ਵਧੇਗਾ ਭਾਵੇਂ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਾ ਕੀਤੀ ਗਈ ਹੋਵੇ।\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਅੱਪਡੇਟ ਕੀਤੀ ਸਕ੍ਰਿਪਟ ਹੈ।ਜੇਕਰ ਕੋਈ ਨਵੀਂ ਵਸਤੂ ਪੈਦਾ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਤਾਂ ਲਾਈਨ ਤੋਂ ਬਿਨਾਂ ਜੋ ਨੰਮਸ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈਃ \\n \'\\nਊਜ਼ਿੰਗ ਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ ਸਪੌਨਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ\\n {\\n ਪਬਲਿਕਬੂਲ ਇਨੇਬਲ ਸਪੌਨਰ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨ ਇੰਟਰਵਲ; \\n ਪਬਲਿਕ ਇੰਟ ਨੰਮਸਪੌਨਡ; \\n ਪਬਲਿਕ ਫਲੋਟ ਸਪੌਨਰੇਡੀਅਸ; \\n ਪਬਲਿਕ ਗੇਮ ਆਬਜੈਕਟ [] ਪ੍ਰੀਫੈਬਲਿਸਟ; \\n ਪਬਲਿਕਫਲੋਟ [] ਸੰਭਾਵਨਾ ਸੂਚੀ; \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਸਟਾਰਟ () \\n {\\n ਜੇਕਰ (ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ ਅੱਪਡੇਟ () \\n {\\n ਜੇਕਰ(Input.GetKeyDown (KeyCode.Space)) \\n {\\n NAME _ 1 (); \\n} \\n ਪ੍ਰਾਈਵੇਟ ਵਾਇਲਡ NAME _ 1 () \\n {\\n ਜੇਕਰ (Random.Range (0f, 1f) <ਸੰਭਾਵਨਾ ਸੂਚੀ [Random.Range (0,probabilityList.Length)]) \\n {\\n ਲਈ (ਇੰਟ i = 0; i <numSpawnd; i + +) \\n {\\n ਵੈਕਟਰ3 ਸਪੌਨਪੁਆਇੰਟ = Random.insideUnitSphere * ਸਪੌਨਰੇਡੀਅਸ +transform.position; \\n ਇੰਸਟੈਂਸ਼ੀਏਟ (ਪ੍ਰੀਫੈਬਲ ਲਿਸਟ [Random.Range (0, prefabList.Length)], ਸਪੌਨਪੁਆਇੰਟ, Quaternion.identity); \\n} \\n ਨੰਮਸਪੌਨਡ = 0; \\n} \\n ਹੋਰ \\n{\\n numSpawned + +; \\n} \\n ਜੇਕਰ (numSpawned> = numSpawned * spawnInterval) \\n {\\n ਜੇਕਰ (! enableSpawner) \\n {\\n enable = false; \\n} \\n} \\n \',\' ਕੀ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ?ਮੈਨੂੰ ਹਟਾਈਆਂ ਗਈਆਂ ਲਾਈਨਾਂ ਵੇਖੋ? \',\' ਯਕੀਨਨ, ਇਹ ਉਹ ਲਾਈਨਾਂ ਹਨ ਜੋ ਹਟਾਈਆਂ ਗਈਆਂ ਸਨਃ \\n \'if (numSpawned> = numSpawned * spanInterval) \\n {\\n ਜੇਕਰ(! ਇਨੇਬਲ ਸਪੌਨਰ) \\n {\\n ਸਮਰੱਥ = ਗਲਤ; \\n} \\n} \'\\n ਇਹ ਲਾਈਨਾਂ ਹਟਾ ਦਿੱਤੀਆਂ ਗਈਆਂ ਸਨ ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੀਆਂ ਸਨ ਅਤੇ ਇਹਨਾਂ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਵਿੱਚ ਯੋਗਦਾਨ ਨਹੀਂ ਪਾਉਂਦੀਆਂ ਸਨ।ਸਕ੍ਰਿਪਟ। \',\' ਤੁਹਾਨੂੰ ਧੰਨਵਾਦ, ਇਹ ਪਹਿਲੀ ਵਾਰ ਹੈ ਜਦੋਂ ਮੈਂ ਇੰਸਾਈਡਯੂਨਿਟਸਫੀਅਰ ਬਾਰੇ ਸੁਣਿਆ ਹੈ ਅਤੇ ਇਹ ਭਵਿੱਖ ਲਈ ਬਹੁਤ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ! \',\' ਤੁਹਾਡਾ ਸਵਾਗਤ ਹੈ! ਮੈਂ ਹਾਂਖੁਸ਼ੀ ਹੈ ਕਿ ਮੈਂ ਮਦਦ ਕਰ ਸਕਦਾ ਹਾਂ। "", ਯੂਨਿਟੀ ਵਿੱਚ ਇੱਕ ਐਨੀਮੇਟਰ ਨੂੰ ਤਿਆਰ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਕੀ ਹੈ ਜੋ ਦੋ ਵੱਖ-ਵੱਖ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਿਟਾਂ ਲਈ ਇਕੱਠੇ ਕਰਦਾ ਹੈ। ", \'ਜੇ ਤੁਸੀਂ ਮਦਦ ਕਰ ਸਕਦੇ ਹੋ।ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ ਲਈ ਦੋ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਿੰਕ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ ਹਰੇਕ ਸਪ੍ਰਾਈਟ ਲਈ ਇੱਕ ਨਵੀਂ ਪਰਤ ਬਣਾ ਸਕਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਪਰਤਾਂ ਨੂੰ ਐਨੀਮੇਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।ਫਿਰ, ਐਨੀਮੇਟਰ ਕੰਟਰੋਲਰ ਵਿੱਚ, ਤੁਸੀਂ ਦੋਵਾਂ ਲੇਅਰਾਂ ਨੂੰ ਇੱਕੋ ਐਨੀਮੇਸ਼ਨ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਮਕਾਲੀ ਕੀਤਾ ਜਾ ਸਕੇ। \',\' ਕੀ ਤੁਸੀਂ ਇੱਕ ਉਦਾਹਰਣ ਵਜੋਂ C #ਕੋਡ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹੋ? \',"ਯਕੀਨਨ, ਇੱਥੇ C #ਕੋਡ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਦੋ ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ ਲਈ ਦੋ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਇਕੱਠੇ ਸਿੰਕ ਕਰਦੀ ਹੈਃ \\n \'\\nਊਜ਼ਿੰਗ ਯੂਨਿਟੀ ਇੰਜਣ; \\nਪਬਲਿਕ ਕਲਾਸ।ਐਨੀਮੇਟਰ ਕੰਟਰੋਲਰਃ ਮੋਨੋਬਿਹੇਵੀਅਰ \\n {\\n ਪ੍ਰਾਈਵੇਟ ਐਨੀਮੇਟਰ ਐਨੀਮੇਟਰ; \\n ਪ੍ਰਾਈਵੇਟ ਸਪਰਾਈਟ ਰੈਂਡਰ ਸਪਰਾਈਟ ਰੈਂਡਰ1; \\n ਪ੍ਰਾਈਵੇਟ ਸਪਰਾਈਟ ਰੈਂਡਰspriteRenderer2; \\n// ਸਟਾਰਟ ਨੂੰ ਪਹਿਲੇ ਫਰੇਮ ਅੱਪਡੇਟ ਤੋਂ ਪਹਿਲਾਂ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ \\n ਵੋਇਡ ਸਟਾਰਟ () \\n {\\n ਐਨੀਮੇਟਰ = GetCਮ੍ਪੋਨੇਟ <ਐਨੀਮੇਟਰ> (); \\n spriteRenderer1 =GetComponent <SpriteRenderer> (); \\n spriteRenderer2 = GetComponent <SpriteRenderer> (); \\n} \\n ਪਬਲਿਕ ਵੋਇਡ ਸਿੰਕਐਨੀਮੇਸ਼ਨਜ਼ () \\n {\\nanimator.SetLayerWeight (0,1); \\n spriteRenderer1.enabled = ਗਲਤ; \\n spriteRenderer2.enabled = ਗਲਤ; \\n animator.SetLayerWeight (1,1); \\nspriteRenderer1.enabled = ਸੱਚ; \\n spriteRenderer2.enabled = ਸੱਚ; \\n} \\n} \\n "\'\\n ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਦੋ ਲਈ ਐਨੀਮੇਟਰ ਕੰਪੋਨੈਂਟ ਅਤੇ ਸਪਰਾਈਟ ਰੈਂਡਰਰਸ ਮਿਲਦਾ ਹੈ।ਵੱਖ-ਵੱਖ ਸਪ੍ਰਾਈਟਸ। ਇਹ ਫਿਰ ਦੋ ਸਪ੍ਰਾਈਟ ਰੈਂਡਰਰਸ ਨੂੰ ਅਯੋਗ ਕਰ ਦਿੰਦਾ ਹੈ ਅਤੇ ਐਨੀਮੇਸ਼ਨਾਂ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਲਈ ਐਨੀਮੇਟਰ ਦੀ ਪਰਤ ਦਾ ਭਾਰ 1 ਸੈੱਟ ਕਰਦਾ ਹੈ। ਅੰਤ ਵਿੱਚ, ਇਹਸਪਰਾਈਟ ਰੈਂਡਰਰਸ ਨੂੰ ਐਨੀਮੇਸ਼ਨ ਦਿਖਾਉਣ ਲਈ ਮੁਡ਼ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ। ", \'ਇਹ ਕੰਪੋਨੈਂਟ ਕਿੱਥੇ ਮਾਊਂਟ ਹੁੰਦਾ ਹੈ?\', \'ਇਸ ਕੰਪੋਨੈਂਟ ਨੂੰ ਕਿਸੇ ਵੀ ਗੇਮ ਆਬਜੈਕਟ ਉੱਤੇ ਮਾਊਂਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।ਜਿਸ ਵਿੱਚ ਇੱਕ ਐਨੀਮੇਟਰ ਕੰਪੋਨੈਂਟ ਹੈ। \',\' ਮੈਂ ਸੀਨ ਵਿੱਚ ਸਪਰਾਈਟਸ ਦੇ ਇੱਕ ਵੱਡੇ ਪੂਲ ਵਿੱਚੋਂ ਸਹੀ ਸਪਰਾਈਟਸ ਦੀ ਚੋਣ ਕਿਵੇਂ ਕਰਾਂ? \',\' ਤੁਸੀਂ ਇੱਕ ਖਾਸ ਸਪਰਾਈਟ ਦੀ ਚੋਣ ਕਰ ਸਕਦੇ ਹੋ।ਇਸ ਦੇ ਨਾਮ ਜਾਂ ਟੈਗ ਦੁਆਰਾ। ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਸੀਨ ਵਿੱਚ ਸਪਰਾਈਟਸ ਦਾ ਇੱਕ ਵੱਡਾ ਪੂਲ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਹਰੇਕ ਸਪਰਾਈਟ ਰਾਹੀਂ ਦੁਹਰਾਉਣ ਲਈ ਇੱਕ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸ ਦੇ ਨਾਮ ਜਾਂ ਟੈਗ ਦੀ ਤੁਲਨਾ ਕਰ ਸਕਦੇ ਹੋ।ਇੱਕ ਖਾਸ ਮੁੱਲ ਨੂੰ ਟੈਗ ਕਰੋ। ਇੱਥੇ C #ਕੋਡ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਇੱਕ ਖਾਸ ਸਪਰਾਈਟ ਦੀ ਚੋਣ ਕਰਦੀ ਹੈਃ \\n "\'\\nusing UnityEngine; \\npublick class SpriteSlector:ਮੋਨੋਬਿਹੇਵੀਅਰ \\n {\\n ਪਬਲਿਕ ਸਟਰਿੰਗ ਸਪਰਾਈਟਨਾਮ; \\n ਪਬਲਿਕ ਸਟਰਿੰਗ ਟੈਗ; \\n ਪ੍ਰਾਈਵੇਟ ਸਪਰਾਈਟ ਰੈਂਡਰ ਸਪਰਾਈਟ ਰੈਂਡਰ; \\n// ਸਟਾਰਟ ਨੂੰ ਪਹਿਲੇ ਫਰੇਮ ਤੋਂ ਪਹਿਲਾਂ ਕਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।ਅੱਪਡੇਟ \\n ਵੋਇਡ ਸਟਾਰਟ () \\n {\\n ਸਪਰਾਈਟ ਰੈਂਡਰਰ = ਗੇਟ ਕੰਪੋਨੈਂਟ <ਸਪਰਾਈਟ ਰੈਂਡਰਰ> (); \\n} \\n ਪਬਲਿਕ ਵੋਇਡ ਚੁਣੋ ਸਪਰਾਈਟ () \\n {\\n ਫੋਰੈਚ (ਸਪਰਾਈਟ ਰੈਂਡਰਰ ਸਪਰਾਈਟ ਇਨਲੱਭੋ ਆਬਜੈਕਟਸਓਫ ਟਾਈਪ <ਸਪ੍ਰਾਈਟ ਰੈਂਡਰਰ> ()) \\n {\\n ਜੇਕਰ (sprite.name = = ਸਪ੍ਰਾਈਟਨਾਮ।। sprite.tag = = ਟੈਗ) \\n {\\n spriteRenderer.enabled = ਸੱਚ; \\n ਬਰੇਕ; \\n} \\nਨਹੀਂ ਤਾਂ \\n {\\n ਜਾਰੀ ਹੈ; \\n} \\n} \\n} \\n "\\n" ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਪ੍ਰਾਈਟ ਰੈਂਡਰਰ ਕੰਪੋਨੈਂਟ ਮਿਲਦਾ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਸਾਰੇ ਸਪ੍ਰਾਈਟ ਰੈਂਡਰਸ ਰਾਹੀਂ ਦੁਹਰਾਉਣ ਲਈ ਇੱਕ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਦ੍ਰਿਸ਼। ਹਰੇਕ ਸਪਰਾਈਟ ਰੈਂਡਰ ਲਈ, ਇਹ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਇਸ ਦਾ ਨਾਮ ਜਾਂ ਟੈਗ ਨਿਰਧਾਰਤ ਮੁੱਲ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਜੇ ਕੋਈ ਮੇਲ ਮਿਲਦਾ ਹੈ, ਤਾਂ ਇਹ ਸਪਰਾਈਟ ਰੈਂਡਰ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ।\',\' ਸੈੱਟਲੇਅਰਵੇਟ () ਐਨੀਮੇਟਰ ਕਲਾਸ ਵਿੱਚ ਇੱਕ ਵਿਧੀ ਹੈ ਜੋ ਐਨੀਮੇਟਰ ਵਿੱਚ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਪਰਤ ਦਾ ਭਾਰ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ।ਪਰਤ ਦਾ ਭਾਰ ਫਰੇਮ ਦੇ ਅੰਤਿਮ ਰੈਂਡਰਿੰਗ ਵਿੱਚ ਐਨੀਮੇਟਰ ਦੇ ਯੋਗਦਾਨ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਇੱਕ ਪਰਤ ਦਾ ਭਾਰ 1 ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਪਰਤ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਰਗਰਮ ਹੈ।ਅਤੇ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ। ਜੇਕਰ ਇੱਕ ਪਰਤ ਦਾ ਭਾਰ 0 ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਪਰਤ ਸਰਗਰਮ ਅਤੇ ਅਦਿੱਖ ਹੈ। ", \'ਕੀ ਇਹ ਸਪਰਾਈਟ ਐਨੀਮੇਸ਼ਨਾਂ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ?\' ', 'ਕੀ ਤੁਸੀਂ ਯੂਨਿਟੀ ਗੇਮ ਇੰਜਣ ਵਿੱਚ ਇੱਕ ਸੰਰਚਨਾ ਯੋਗ ਸਪੌਨਰ ਕੰਪੋਨੈਂਟ ਲਈ ਇੱਕ C #ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ।ਅੰਤਰਾਲ ਨੂੰ ਟਵੀਕ ਕਰੋ, ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰਤੀ ਅੰਦਰੂਨੀ ਅਤੇ ਪ੍ਰੀਫੈਬ ਸੂਚੀ ਵਿੱਚ ਪੈਦਾ ਕੀਤੀ ਗਈ ਰਕਮ ਚੁਣੋ ਕਿ ਕੀ ਪੈਦਾ ਹੋਇਆ ਹੈ, ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਬਿੰਦੂ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਇੱਕ ਰੇਡੀਅਸਸਪੌਨਰ ਦੇ ਦੁਆਲੇ ਚੱਕਰ ਵਿੱਚ. \n ']