👨🏻‍🔧 🍴 🙌🏾 खेल "जीवन"। फिर। इस बार 3 डी में 🍔 👩‍👦‍👦 🍮

पिछले सप्ताह के दौरान, हैबर को खेल "लाइफ" के बारे में कई लेखों के साथ फिर से भर दिया गया। खैर, फिर मैं इस विषय पर अपनी सर्वोत्तम प्रथाओं को साझा करूंगा।

प्रस्तावना

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

चरण 1. सेलुलर ऑटोमेटन

मुझे लगता है कि यहां हर कोई (अच्छी तरह से, या लगभग सभी) एक सेलुलर ऑटोमेटन की कल्पना करता है। इसलिए, हम सिद्धांत में नहीं झुकेंगे, लेकिन तुरंत अभ्यास के लिए आगे बढ़ेंगे। केवल एक चीज जो इस सेलुलर ऑटोमेटन को सबसे आदिम से अलग करती है, वह यह है कि गणना को समानांतर करना आवश्यक था। हालांकि, भविष्य में, कुछ और जोड़ा जाएगा, लेकिन अभी हम इसके बारे में बात नहीं करेंगे। हमारे उद्देश्यों के लिए सेलुलर ऑटोमेटन (इसके बाद केए) को समकालिक होना चाहिए। सौभाग्य से, यहां तक कि एल्गोरिथ्म के समानांतर कार्यान्वयन के साथ, यह कोई असुविधा पैदा नहीं करता है। ओपनएमपी के साथ काम करते समय, यह सिर्फ एक लूप लगाने के लिए पर्याप्त है जो {} ब्लॉक के लिए #pragma omp में अंतरिक्ष यान के मूल्य की गणना करता है।

कुछ इस तरह

#pragma omp parallel shared(Temp, Space, Size) private(Num_of_nbr, x, y, z) { #pragma omp for for (x = 0; x < Size; x++) for (y = 0; y < Size; y++) for (z = 0; z < Size; z++) { // Neighbors(x, y, z)  -  //    x, y  z Num_of_nbr = Neighbors(x, y, z); if (Space[x][y][z] == 1) if (Num_of_nbr <= Smid + Sdiff * Koeff[Int_Temp[x][y][z]] \ && Num_of_nbr >= Smid - Sdiff * Koeff[Int_Temp[x][y][z]]) Temp[x][y][z] = 1; else Temp[x][y][z] = 0; else if (Num_of_nbr <= Bmid + Bdiff * Koeff[Int_Temp[x][y][z]] \ && Num_of_nbr >= Bmid - Bdiff * Koeff[Int_Temp[x][y][z]]) Temp[x][y][z] = 1; else Temp[x][y][z] = 0; } #pragma omp for for (x = 0; x < Size; x++) for (y = 0; y < Size; y++) for (z = 0; z < Size; z++) Space[x][y][z] = Temp[x][y][z]; }

चरण 2. दृश्यांकन करनेवाला

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

मंच 3. बाहरी प्रभाव

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

पूर्णांक प्रसार

 #pragma omp parallel shared(Size, BlockSize, Int_Temp, PosCell, PosNbr, DiffKoeff)\ private(CellNum, NbrNum, x, y, z, Cell1, Cell2, Rem1, Rem2, Mov1, Mov2) { CellNum = rand() % 27; #pragma omp for for (x = 1; x < Size; x += BlockSize) for (y = 1; y < Size; y += BlockSize) for (z = 1; z < Size; z += BlockSize) { NbrNum = rand() % 6; Cell1 = Int_Temp[(x + PosCell[CellNum][0] + Size) % Size] \ [(y + PosCell[CellNum][1] + Size) % Size] \ [(z + PosCell[CellNum][2] + Size) % Size]; Cell2 = Int_Temp[(x +PosCell[CellNum][0] + PosNbr[NbrNum][0] + Size) % Size] \ [(y + PosCell[CellNum][1] + PosNbr[NbrNum][1] + Size) % Size] \ [(z + PosCell[CellNum][2] + PosNbr[NbrNum][2] + Size) % Size]; //DiffKoeff ,    //  ,     . Rem1 = Cell1 * (float)(1.0 - DiffKoeff); Rem2 = Cell2 * (float)(1.0 - DiffKoeff); Mov1 = Cell1 * DiffKoeff; Mov2 = Cell2 * DiffKoeff; if ((float)Cell1 * DiffKoeff - (float)Mov1 > (float)(rand() % 10) / 10.0) Rem1++; else if ((float)Cell1 * DiffKoeff - (float)Mov1) Mov1++; if ((float)Cell2 * DiffKoeff - (float)Mov2 > (float)(rand() % 10) / 10.0) Rem2++; else if ((float)Cell2 * DiffKoeff - (float)Mov2) Mov2++; Int_Temp[(x + PosCell[CellNum][0] + Size) % Size] \ [(y + PosCell[CellNum][1] + Size) % Size] \ [(z + PosCell[CellNum][2] + Size) % Size] = Mov2 + Rem1; Int_Temp[(x +PosCell[CellNum][0] + PosNbr[NbrNum][0] + Size) % Size] \ [(y + PosCell[CellNum][1] + PosNbr[NbrNum][1] + Size) % Size] \ [(z + PosCell[CellNum][2] + PosNbr[NbrNum][2] + Size) % Size] \ = Mov1 + Rem2; } }

आगे के दृष्टिकोण

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

परिणाम

अब, अंत में, हम सबसे दिलचस्प पर आगे बढ़ सकते हैं।
सबसे पहले, कार्यक्रम को एक तापमान परत के बिना परीक्षण किया गया था, तब से यह बस वहां नहीं था। दुर्भाग्य से, कार्यक्रम में एक सामान्य इंटरफ़ेस नहीं है, और मुझे एक परीक्षण जनरेटर लिखना था। वह कोई विशेष रुचि नहीं है। उनका एकमात्र कार्य खेल के स्थान के केंद्र में कोशिकाओं का एक घन बनाना है। नीचे क्यूब्स 3x3x3, 4x4x4 और 5x4x5 हैं। यहाँ क्या हो रहा है की एक सामान्य तस्वीर पाने के लिए बस कुछ कदम हैं।

3x3x3, चरण 1:

3x3x3, चरण 4:

3x3x3, चरण 5 और 6:

यह बहुत अजीब फ्लैशर निकला।

4x4x4 चरण 1:

4x4x4, चरण 10:

4x4x4 चरण 100:

इसके अलावा व्यावहारिक रूप से कुछ भी नहीं बदलता है।

5x5x5, चरण 1:

5x5x5, चरण 4:

5x5x5, चरण 7:

5x5x5, चरण 8:

अगले चरण में, एक भी जीवित कोशिका नहीं बची है।

अब तापमान को 4x4x4 क्यूब में जोड़ें। तापमान की परत को केंद्रीय कटौती के रूप में प्रस्तुत किया जाता है। लाल इष्टतम तापमान है, पीला सामान्य से थोड़ा नीचे है, और गुलाबी कम है। गेम स्पेस में आयाम 50x50x50 हैं, केंद्र में इष्टतम तापमान के साथ 40x40x40 घन है। यहाँ क्या हुआ है।

चरण 1:

चरण 10:

चरण 50:

चरण 150:

चरण 200:

सब कुछ बहुत स्पष्ट है: हवा ठंडी होती है, जीवन बंद हो जाता है।

दुर्भाग्यवश, मैं इस कार्यक्रम को स्वयं साझा नहीं कर सकता, क्योंकि इनपुट डेटा जनरेटर में हार्डकोड है। लेकिन मैं स्रोत साझा कर सकता हूं, लेकिन मैं आपको तुरंत चेतावनी देता हूं: कोड बस भयानक है।

स्रोत कोड

जनक
अनुसूचित जाति
विजुआलाइज़र