परिचय

तो, आप चाहते हैं या एक ताल खेल बनाने की कोशिश की, लेकिन खेल तत्वों और संगीत जल्दी से सिंक से बाहर है, और अब आप नहीं जानते कि क्या करना है। यह लेख आपको इसमें मदद करेगा। मैंने हाई स्कूल से ताल के खेल खेले और अक्सर स्थानीय आर्केड हॉल में डीडीआर पर लटका दिया। आज मैं हमेशा इस शैली के नए खेल की तलाश में हूं, और इस तरह की परियोजनाएं जैसे कि क्रिप्टोकरेंसी या बिट.ट्रिप। रनर बताते हैं कि इस शैली में बहुत कुछ किया जा सकता है। मैंने एकता में लय के खेल के प्रोटोटाइप पर थोड़ा काम किया, और इसके परिणामस्वरूप मैंने एक महीने के लिए लयबद्ध खेल / पहेली परमाणु बीट्स बनाया । इस लेख में, मैं सबसे उपयोगी कोड-निर्माण तकनीकों के बारे में बात करूंगा जो मैंने इन खेलों को बनाने में सीखा। मुझे उनके बारे में कहीं और जानकारी नहीं मिली, या इसे कम विवरण में प्रस्तुत किया गया।

सबसे पहले, मुझे यू-चाओ के लिए ताल ताल में संगीत समन्वय के अनुवाद के लिए अपनी गहरी कृतज्ञता व्यक्त करनी चाहिए [ हेबेरा में अनुवाद ]। यू ने एकता में गेम इंजन के साथ ऑडियो टाइमिंग को सिंक्रनाइज़ करने की मूल बातों की समीक्षा की और अपने बूट्स-कट गेम के लिए स्रोत कोड अपलोड किया, जिससे मुझे अपनी परियोजना बनाने में बहुत मदद मिली। यदि आप एकता के संगीत तुल्यकालन का संक्षिप्त परिचय सीखना चाहते हैं, तो आप उनके पोस्ट का अध्ययन कर सकते हैं, लेकिन मैं इस विषय को और अधिक विस्तार से और अधिक विस्तार से बताऊंगा। मेरा कोड सक्रिय रूप से लेख और बूट्स-कट कोड की जानकारी का उपयोग करता है।

किसी भी ताल खेल के दिल में समय है। लय टाइमिंग में किसी भी विकृति के लिए लोग बेहद संवेदनशील होते हैं, इसलिए यह बहुत महत्वपूर्ण है कि लय के खेल में सभी क्रियाओं, आंदोलनों और इनपुट को सीधे संगीत के साथ सिंक्रनाइज़ किया जाता है। दुर्भाग्य से, पारंपरिक यूनिटी टाइम ट्रैकिंग तरीके जैसे Time.timeSinceLevelLoad और Time.time जल्दी से ध्वनि के साथ सिंक्रनाइज़ेशन खो देते हैं। इसलिए, हम सीधे AudioSettings.dspTime का उपयोग करके ऑडियो सिस्टम तक पहुंच प्राप्त करेंगे, जो ऑडियो सिस्टम द्वारा संसाधित ऑडियो नमूनों की सही संख्या का उपयोग करता है। इसके लिए धन्यवाद, यह हमेशा संगीत के साथ सिंक्रनाइज़ेशन बनाए रखता है जिसे वापस बजाया जा रहा है (शायद यह बहुत लंबी ऑडियो फ़ाइलों के साथ नहीं है, जब नमूना प्रभाव खेल में आता है, लेकिन एक सामान्य लंबाई के गाने के मामले में, सिस्टम को पूरी तरह से काम करना चाहिए)। यह फ़ंक्शन हमारी रचना समय ट्रैकिंग का मूल होगा, और इसके आधार पर हम मुख्य वर्ग बनाएंगे।

क्लास कंडक्टर

कंडक्टर वर्ग मुख्य रचना प्रबंधन वर्ग है जिसके आधार पर बाकी ताल खेल का निर्माण किया जाएगा। इसके साथ, हम संरचना की स्थिति को ट्रैक करेंगे और अन्य सभी सिंक्रनाइज़ किए गए कार्यों का प्रबंधन करेंगे। रचना को ट्रैक करने के लिए हमें कुछ चरों की आवश्यकता होती है

//Song beats per minute //This is determined by the song you're trying to sync up to public float songBpm; //The number of seconds for each song beat public float secPerBeat; //Current song position, in seconds public float songPosition; //Current song position, in beats public float songPositionInBeats; //How many seconds have passed since the song started public float dspSongTime; //an AudioSource attached to this GameObject that will play the music. public AudioSource musicSource; 

दृश्य शुरू करते समय, हमें चर निर्धारित करने के लिए गणना करने की आवश्यकता होती है, और रचना के आरंभ समय का संदर्भ देने के लिए भी रिकॉर्ड किया जाता है।

 void Start() { //Load the AudioSource attached to the Conductor GameObject musicSource = GetComponent<AudioSource>(); //Calculate the number of seconds in each beat secPerBeat = 60f / songBpm; //Record the time when the music starts dspSongTime = (float)AudioSettings.dspTime; //Start the music musicSource.Play(); } 

यदि आप इस तरह से जुड़ी हुई स्क्रिप्ट के साथ एक खाली गेमऑबजेक्ट बनाते हैं, और फिर रचना के साथ ऑडियो स्रोत जोड़ते हैं और प्रोग्राम चलाते हैं, तो आप देखेंगे कि स्क्रिप्ट रचना के प्रारंभ समय को रिकॉर्ड करेगी, लेकिन और कुछ नहीं होगा। हमें उस ऑडियो के बीपीएम को मैन्युअल रूप से दर्ज करना होगा जिसे हम ऑडियो स्रोत से जोड़ते हैं।


इन सभी मूल्यों के लिए धन्यवाद, हम गेम को अपडेट करते समय वास्तविक समय में रचना में स्थिति को ट्रैक कर सकते हैं। हम रचना का समय निर्धारित करेंगे, पहले सेकंड में, फिर अंशों में। किसी रचना को ट्रैक करने के लिए अंश अधिक सुविधाजनक तरीका है, क्योंकि वे हमें रचनाओं के समानांतर समय में क्रियाओं और समय को जोड़ने की अनुमति देते हैं, उदाहरण के लिए, भिन्न 1, 3 और 5.5 में, भिन्न के बीच सेकंड की गणना करने की आवश्यकता के बिना। कंडक्टर वर्ग के अद्यतन () समारोह में निम्नलिखित गणनाएँ जोड़ें:

 void Update() { //determine how many seconds since the song started songPosition = (float)(AudioSettings.dspTime - dspSongTime); //determine how many beats since the song started songPositionInBeats = songPosition / secPerBeat; } 

तो हमें ऑडियो सिस्टम और रचना के प्रारंभ समय के अनुसार वर्तमान समय के बीच का अंतर मिलता है, जो रचना को चलाने के लिए सेकंड की कुल संख्या देता है। हम इसे सॉन्गपिशन वेरिएबल में सेव करेंगे।


ध्यान दें कि संगीत में स्कोर आमतौर पर 1-2-3-4 और इतने पर अंशों के साथ एक इकाई के साथ शुरू होता है, और गीतपोसिशनइनबीट्स 0 से शुरू होता है और इस मूल्य से बढ़ता है, इसलिए रचना का तीसरा भाग गीतपोजिशनबीट्स के अनुरूप होगा, जो 2.0 है, 3.0 नहीं।

इस बिंदु पर, यदि आप एक पारंपरिक नृत्य नृत्य क्रांति-शैली का खेल बनाना चाहते हैं, तो आपको उन अंशों के अनुसार नोट्स बनाने की आवश्यकता होती है, जिन्हें आपको उन्हें दबाने की आवश्यकता होती है, क्लिक लाइन के सापेक्ष उनकी स्थिति को प्रक्षेपित करें, और फिर कुंजी दबाए जाने पर songPositionInBeats रिकॉर्ड करें और नोटों के वांछित अनुपात के साथ मूल्य की तुलना करें। यू चाओ अपने लेख में इस तरह की एक योजना के उदाहरण पर चर्चा करते हैं। अपने आप को नहीं दोहराने के लिए, मैं अन्य संभावित उपयोगी तकनीकों पर विचार करूंगा जो कंडक्टर वर्ग के शीर्ष पर बनाई जा सकती हैं। एटॉमिक बीट्स बनाते समय मैंने उनका इस्तेमाल किया।

हम शुरुआती हिस्से के अनुकूल हैं

यदि आप एक ताल खेल के लिए अपना खुद का संगीत बनाते हैं, तो पहले बीट को संगीत की शुरुआत से बिल्कुल मैच करना आसान होता है, जो कि अगर सही ढंग से निर्दिष्ट किया गया है, तो मज़बूती से कंडक्टर वर्ग के गीतपुनिशन.बीट्स को रचना में बाँध देगा।


हालांकि, यदि आप तैयार-किए गए संगीत का उपयोग करते हैं, तो एक उच्च संभावना है कि रचना की शुरुआत से पहले थोड़ा सा ठहराव है। यदि इस पर ध्यान नहीं दिया जाता है, तो कंडक्टर वर्ग गीतपोसिशनइन्बीटस सोचेंगे कि पहली बीट तब शुरू हुई जब गाना बजना शुरू हुआ, और अब बीट नहीं। वह सब कुछ जो आगे शेयरों के मूल्यों से जुड़ा होगा, संगीत के साथ सिंक्रनाइज़ नहीं है।


इसे ठीक करने के लिए, आप एक चर जोड़ सकते हैं जो इस ऑफसेट को ध्यान में रखता है। निम्नलिखित को कंडक्टर वर्ग में जोड़ें:

 //The offset to the first beat of the song in seconds public float firstBeatOffset; 

अद्यतन () में, गीत संग्रह:

 songPosition = (float)(AudioSettings.dspTime - dspSongTime); 

द्वारा प्रतिस्थापित:

 songPosition = (float)(AudioSettings.dspTime - dspSongTime - firstBeatOffset); 

अब गीतपोजीशन गीत में स्थिति की सही गणना करेगा, सही पहली बाजी को ध्यान में रखते हुए। हालांकि, आपको मैन्युअल रूप से पहले बीट में ऑफसेट दर्ज करना होगा, इसलिए प्रत्येक फ़ाइल के लिए यह अद्वितीय होगा। इसके अलावा, इस बदलाव के दौरान एक छोटी खिड़की होगी जिसमें गीतों को नकारात्मक रूप दिया जाएगा। यह गेम को प्रभावित नहीं कर सकता है, लेकिन कुछ कोड गीतपंजी या गीतपोसिशनइन्बीट के मूल्यों पर निर्भर करता है, इस समय नकारात्मक संख्याओं को संसाधित करने में सक्षम नहीं हो सकता है।

रिप्ले

यदि आप एक रचना के साथ काम करते हैं जो शुरुआत से अंत तक खेलती है, तो ऊपर दिखाए गए कंडक्टर वर्ग स्थिति को ट्रैक करने के लिए पर्याप्त होगा। लेकिन अगर आपके पास एक छोटा ट्रैक है जो लूप किया गया है और आप इस लूप के साथ काम करना चाहते हैं, तो आपको कंडक्टर में रिपीटर सपोर्ट बनाने की जरूरत है।

यदि आपके पास पूरी तरह से लूपेड टुकड़ा है (उदाहरण के लिए, यदि गीत टेम्पो 120 बीपीएम है, और लूप किए गए टुकड़े की लंबाई 4 बीट है, तो यह कंडक्टर वर्ग के ऑडियो स्रोत वर्ग में लोड किया गया, यह बिल्कुल 8.0 सेकंड प्रति सेकंड में 8.0 सेकंड होना चाहिए) फिर लूप बॉक्स की जांच करें। कंडक्टर पहले की तरह ही काम करेगा, और क्लिप की पहली शुरुआत के बाद गीत-संग्रह के लिए कुल समय स्थानांतरित करेगा। लूप की स्थिति निर्धारित करने के लिए, हमें किसी तरह कंडक्टर को बताना होगा कि एक लूप में कितने शेयर हैं और कितने लूप पहले ही खेले जा चुके हैं। कंडक्टर वर्ग में निम्नलिखित चर जोड़ें:

 //the number of beats in each loop public float beatsPerLoop; //the total number of loops completed since the looping clip first started public int completedLoops = 0; //The current position of the song within the loop in beats. public float loopPositionInBeats; 

अब SongPositionInBeats के प्रत्येक अपडेट के साथ, हम लूप के अपडेट () स्थिति को भी अपडेट कर सकते हैं।

 //calculate the loop position if (songPositionInBeats >= (completedLoops + 1) * beatsPerLoop) completedLoops++; loopPositionInBeats = songPositionInBeats - completedLoops * beatsPerLoop; 

यह हमें एक मार्कर देता है जो लूपपोजिशन बताता है। धड़कन के माध्यम से हम कितने शेयरों में गए, जो कई अन्य सिंक्रनाइज़ किए गए आइटमों के लिए उपयोगी है। गेमऑबजेक्ट कंडक्टर में लूप के शेयरों की संख्या दर्ज करना याद रखें।

हमें शेयरों की गणना पर भी ध्यान से विचार करना चाहिए। संगीत हमेशा 1 से शुरू होता है, इसलिए 4-भाग माप 1-2-3-4- लेता है, और हमारी कक्षा में लूपपोजिशनइनबीट्स 0.0 से शुरू होता है और 4.0 से अधिक छोरों पर होता है। इसलिए, लूप का सटीक मध्य, जो कि संगीत के अनुपात की गणना करते समय 3 होगा, लूप में। InBeats का मान 2.0 होगा। आप इसे ध्यान में रखते हुए लूपपोजिशन इनबीट्स को संशोधित कर सकते हैं, लेकिन यह अन्य सभी गणनाओं को प्रभावित करेगा, इसलिए नोट डालते समय सावधान रहें।

साथ ही शेष उपकरणों के लिए कंडक्टर वर्ग में दो और पहलुओं को जोड़ना उपयोगी होगा। सबसे पहले, LoopPositionInBeats के एक एनालॉग संस्करण को LoopPositionInAnalog कहा जाता है, जो 0 से 1.0 तक की सीमा में लूप की स्थिति को मापता है। दूसरी अन्य कक्षाओं से सुविधाजनक कॉलिंग के लिए कंडक्टर वर्ग का एक उदाहरण है। कंडक्टर वर्ग में निम्नलिखित चर जोड़ें:

 //The current relative position of the song within the loop measured between 0 and 1. public float loopPositionInAnalog; //Conductor instance public static Conductor instance; 

अवेक () फ़ंक्शन में, जोड़ें:

 void Awake() { instance = this; } 

और अद्यतन () फ़ंक्शन में जोड़ें:

 loopPositionInAnalog = loopPositionInBeats / beatsPerLoop; 

सिंक चालू करें

लोब के साथ आंदोलन या रोटेशन को सिंक्रनाइज़ करने के लिए यह बहुत उपयोगी होगा ताकि तत्व सही स्थानों पर हों। अपने परमाणु बीट्स गेम में, मैंने इसे केंद्रीय अक्ष के चारों ओर गतिशील रूप से नोट्स को घुमाने के लिए इस्तेमाल किया। प्रारंभ में, उन्हें लूप के अंदर उनके हिस्से के अनुसार परिधि के चारों ओर रखा गया था, और फिर पूरे खेल क्षेत्र को घुमाया गया ताकि नोटों को उनके हिस्से में अवसाद की रेखा के साथ मिलान किया गया।

इसे प्राप्त करने के लिए, SyncedRotation नामक एक नई स्क्रिप्ट बनाएं, और इसे गेमऑबजेक्ट में संलग्न करें जिसे आप घुमाना चाहते हैं। SyncedRotation स्क्रिप्ट के अपडेट () फ़ंक्शन में जोड़ें:

 void Update() { this.gameObject.transform.rotation = Quaternion.Euler(0, 0, Mathf.Lerp(0, 360, Conductor.instance.loopPositionInAnalog)); } 

यह कोड GameObject के रोटेशन को इंटरपोल करेगा कि यह गेम 0 से 360 डिग्री के अंतराल में बंधा हुआ है, जिससे यह मुड़ता है ताकि यह प्रत्येक लूप के अंत में एक पूर्ण क्रांति को पूरा करे। यह एक उदाहरण के रूप में उपयोगी है, लेकिन लूपिंग या फ्रेम-बाय-फ्रेम एनीमेशन के लिए, लूप एनिमेशन को सिंक करना अधिक उपयोगी होगा ताकि वे टेंपो के साथ पूरी तरह से फिट हो सकें।

एनिमेशन सिंक

एकता एनिमेटर बेहद शक्तिशाली है, लेकिन हमेशा सटीक नहीं होता है। एनिमेशन और संगीत के विश्वसनीय संरेखण के लिए, मुझे एनीमेटर वर्ग और इसकी प्रवृत्ति के साथ धीरे-धीरे विघटित होने की प्रवृत्ति से मुकाबला करना पड़ा। इसके अलावा, समान एनिमेशन को अलग-अलग टेम्पो में समायोजित करना मुश्किल था, ताकि रचनाओं के बीच स्विच करते समय, आपको एनीमेशन के मुख्य फ़्रेम को वर्तमान टेम्पो पर फिर से परिभाषित न करना पड़े। इसके बजाय, हम सीधे एनीमेशन लूप में जा सकते हैं, और इस लूप में स्थिति निर्धारित कर सकते हैं कि हम कंडक्टर वर्ग के लूप में कहां हैं।

सबसे पहले, SyncedAnimation नामक एक नया वर्ग बनाएं, और इसमें निम्नलिखित चर जोड़ें:

 //The animator controller attached to this GameObject public Animator animator; //Records the animation state or animation that the Animator is currently in public AnimatorStateInfo animatorStateInfo; //Used to address the current state within the Animator using the Play() function public int currentState; 

इसे एक नए या मौजूदा गेम ऑबजेक्ट में संलग्न करें जिसे आप चेतन करना चाहते हैं। इस उदाहरण में, हम बस वस्तु को आगे और पीछे स्क्रीन पर घुमाएंगे, लेकिन समान सिद्धांत को किसी भी एनीमेशन पर लागू किया जा सकता है, यह संपत्ति, या फ्रेम-बाय-फ्रेम एनीमेशन को सेट करने से पहले हो। GameObject में एक एनिमेटर तत्व जोड़ें और SyncedAnimController नामक एक नया एनिमेटर कंट्रोलर बनाएं, साथ ही बैकएंडफोर्थ नामक एक एनीमेशन क्लिप । हम गेमऑब्जेक्ट से जुड़े एनिमेटर वर्ग में नियंत्रक को लोड करते हैं, और एनीमेशन ट्री को एनीमेशन को डिफ़ॉल्ट एनीमेशन के रूप में जोड़ते हैं।


उदाहरण के लिए, मैंने एनीमेशन सेट किया ताकि वह पहले ऑब्जेक्ट को दाईं ओर 6 इकाइयों तक ले जाए, फिर बाईं ओर -6 तक, और फिर वापस 0 पर ले जाए।


अब, एनीमेशन को सिंक्रनाइज़ करने के लिए, SyncedAnimation वर्ग के प्रारंभ () फ़ंक्शन के लिए निम्न कोड जोड़ें, जो एनिमेटर के बारे में जानकारी को आरंभ करता है:

 void Start() { //Load the animator attached to this object animator = GetComponent<Animator>(); //Get the info about the current animator state animatorStateInfo = animator.GetCurrentAnimatorStateInfo(0); //Convert the current state name to an integer hash for identification currentState = animatorStateInfo.fullPathHash; } 

फिर एनीमेशन सेट करने के लिए अद्यतन () में निम्न कोड जोड़ें:

 void Update() { //Start playing the current animation from wherever the current conductor loop is animator.Play(currentState, -1, (Conductor.instance.loopPositionInAnalog)); //Set the speed to 0 so it will only change frames when you next update it animator.speed = 0; } 

तो हम एनीमेशन को एक पूर्ण लूप के सापेक्ष एनीमेशन के सटीक फ्रेम में रखते हैं। उदाहरण के लिए, यदि आप ऊपर दिए गए एनीमेशन का उपयोग करते हैं, जब आप लूप के बीच में होते हैं, तो गेमऑब्जेक्ट स्थिति केवल 0. पार कर जाएगी। यह आपके द्वारा बनाए गए किसी भी एनीमेशन पर लागू किया जा सकता है जिसे आप कंडक्टर टेम्पो के साथ सिंक्रनाइज़ करना चाहते हैं।

यह भी ध्यान देने योग्य है कि एनिमेशन का एक सहज लूप बनाने के लिए, आपको एनीमेशन वक्र पर एनीमेशन के अलग-अलग keyframes के स्पर्शकों को कॉन्फ़िगर करने की आवश्यकता है। रैखिक सेटिंग एक कुंजी फ्रेम से अगले तक जा रही एक सीधी रेखा बनाएगी, और कॉन्स्टेंट अगले कुंजी फ्रेम तक एक मूल्य में एनीमेशन रखेगा, जो एक झटकेदार और तेज आंदोलन देगा।


हालांकि यह विधि उपयोगी है, यह एनीमेशन के सभी संक्रमणों को प्रभावित करता है, क्योंकि यह एनिमेशनस्टैट को उस स्थिति में रहने का कारण बनता है जिसमें यह था जब स्क्रिप्ट शुरू में चलाया गया था। यह विधि उन वस्तुओं के लिए उपयोगी है, जिन्हें केवल एक सिंक्रनाइज़ेशन एनीमेशन का उपयोग करने की आवश्यकता है, लेकिन विभिन्न सिंक्रनाइज़ किए गए एनिमेशन के साथ अधिक जटिल ऑब्जेक्ट बनाने के लिए, आपको उन कोड को जोड़ने की आवश्यकता है जो इन बदलावों को संसाधित करते हैं और वर्तमान एनिमेशन को वांछित एनीमेशन राज्य के अनुसार सेट करते हैं।

निष्कर्ष

ये कुछ ऐसे पहलू हैं जो परमाणु बीट्स बनाने में मेरे लिए मददगार रहे हैं। उनमें से कुछ को अन्य स्रोतों से एकत्र किया गया था या आवश्यकता से बाहर बनाया गया था, लेकिन उनमें से अधिकांश मुझे तैयार रूप में नहीं मिल सके, इसलिए मुझे आशा है कि यह काम में आता है! शायद मेरे सिस्टम का हिस्सा सीपीयू या ऑडियो सिस्टम सीमाओं के कारण बड़ी परियोजनाओं में उपयोगी नहीं होगा, लेकिन यह गेम जैम या हॉबी प्रोजेक्ट खेलने के लिए एक अच्छा आधार होगा।


संगीत के साथ तालबद्ध ताल, या गेम तत्वों को बनाना मुश्किल हो सकता है। सब कुछ एक स्थिर गति से रखने के लिए, आपको एक मुश्किल कोड की आवश्यकता हो सकती है; एक परिणाम जो आपको निरंतर गति से खेलने की अनुमति देता है वह खिलाड़ी के लिए बहुत आकर्षक हो सकता है। पारंपरिक नृत्य नृत्य क्रांति शैली में खेलों की तुलना में इस शैली में बहुत कुछ किया जा सकता है, और मुझे उम्मीद है कि यह लेख आपको इस तरह की परियोजनाओं को महसूस करने में मदद करता है। मैं यह भी सलाह देता हूं, यदि संभव हो, तो मेरे परमाणु बीट्स गेम का मूल्यांकन करें। मैंने इसे इस वर्ष के वसंत में एक महीने में बनाया, इसमें 8 छोटी पटरियां हैं और यह मुफ़्त है!