GLSL पर 619 हजार टेट्रिस का प्रक्षेपण, उनका प्रतिपादन और एक साधारण बॉट

मेरे पास एक शेडर (एक फ्रेमबफ़र बनावट) के लिए एक साथ चलने वाली अधिकतम संख्या बनाने के लिए एक "विचार" था।

निम्नलिखित एक संक्षिप्त विवरण है कि परिणामी कोड कैसे काम करता है।

यह क्या है:

प्रत्येक टेट्रिस तीन पिक्सेल में काम करता है, 1920x1080 संकल्प के लिए आप एक बार में 619200 प्रतियां चला सकते हैं। ऑटो-प्ले के लिए एक साधारण बॉट भी बनाया।
पोस्ट के अंत में चलाने और स्रोत के लिए लिंक।
अपडेट किया गया वीडियो, शेष क्षेत्रों की संख्या को शून्य तक दिखाता है।

डेटा भंडारण

आकार की टेट्रिस तालिका [10, 22] (10 चौड़ाई, 22 ऊँचाई)।
प्रत्येक कोशिका या तो खाली हो सकती है या खाली नहीं हो सकती है।
संपूर्ण तालिका को संग्रहीत करने के लिए कुल 22 * 10 = 220 बिट्स की आवश्यकता होती है।
एक "पिक्सेल" चार 24-बिट फ़्लोट्स है, प्रति पिक्सेल 96 बिट्स।

नेत्रहीन (डिबग फ़्रेम का एक टुकड़ा), तीन पिक्सेल लाल रंग में हाइलाइट किए गए हैं, यह एक सहेजा गया फ़ील्ड है:

2 * 96 + 24 + 4
दो पिक्सेल, तीसरे पिक्सेल के एक फ्लोट, तीसरे पिक्सेल के दूसरे फ्लोट के 4 बिट्स
तीसरे पिक्सेल Pix3.zw में दो अप्रयुक्त फ़्लोट हैं, वे तर्क की स्थिति को स्टोर करते हैं, अधिक सटीक रूप से

• z तीन आठ-बिट संख्याओं को संग्रहीत करता है [a,b,c]
  - वर्तमान ब्लॉक की एक स्थिति, सरणी में स्थिति की आईडी के रूप में (आकार 220 बिट्स की एक सरणी, अधिकतम स्थिति 220 है जो 0xff से कम है)
  - b समय जब तक ऑटोमैटिक फॉल डाउन (टाइमर) इस नंबर पर प्रत्येक फ्रेम -1 , क्योंकि यह 0 हो गया तब यह ब्लॉक डाउन पर पड़ता है
  - वर्तमान ब्लॉक की सी आईडी
• w [a,b,c] , लेकिन साथ ही पूरे फ्लोट का चिन्ह (धनात्मक या ऋणात्मक) वर्तमान तालिका में खेल के अंत का ध्वज है (इसलिए यदि क्षेत्र अभिभूत नहीं है तो संसाधनों को बर्बाद न करें)
  - एक्शन, नो एक्शन (0), लेफ्ट (1), राइट (2), और इसी तरह, कॉमन में पूरा कोड, एक्शन में दो स्टेट्स होते हैं, लेफ्ट को चेक करते हैं और चेक करते हैं कि लेफ्ट को मूव करना संभव है, तो एक्शन को लेफ्ट_ मूव सेट किया जाता है ।
  - [b,c] 0xffff (16 बिट्स) वर्तमान तालिका के बिंदु, जली हुई रेखाओं की संख्या

तीसरे पिक्सेल के दूसरे फ्लोट में अप्रयुक्त छोड़े गए 20 हैं।

डिबग फ़्रेम दिखा रहा है कि सहेजें तर्क सही तरीके से काम कर रहा है
बाईं ओर आकार में तीन पिक्सेल का एक सफेद क्षेत्र है, विशेष रूप से यह दिखाने के लिए सेट किया गया है कि अंतराल सही ढंग से संसाधित हैं (यदि संकल्प तीन का एक से अधिक नहीं है, तो पट्टी एक कोण पर जाएगी)
लाइन 75 बफर ए पर हालत

मुझे कार्रवाई आईडी की आवश्यकता क्यों है:

• डेटा को तीन पिक्सेल में संग्रहीत किया जाता है, एक साथ तर्क की जांच करना और डेटा को एक फ्रेम में बदलना असंभव है (सभी तर्क को निष्पादित किए बिना और प्रत्येक पिक्सेल में पूरे नक्शे को लोड करने पर, भार दस गुना बढ़ जाएगा)।
• इसलिए, डेटा स्टोरेज लॉजिक प्रत्येक पिक्सेल में काम करता है और प्राप्त कमांड को बाएँ_ चालित करता है, सत्यापन कमांड बाएँ_ चेक को केवल एक पिक्सेल (तीसरे) में निष्पादित किया जाता है।

धीमी जगह

• हर तीसरा पिक्सेल (लॉजिक पिक्सेल) पूरे नक्शे (सभी तीन पिक्सेल को पढ़ता है) को डिकम्प्रेस करता है।
• शेष दो पिक्सेल केवल "खुद" (एक पिक्सेल) को सहेजने की क्रिया करने के लिए डिकम्प्रेस करते हैं।
• कार्रवाई के दौरान, लाइन जला दी गई, एक और पिक्सेल लोड किया गया है, क्योंकि तालिका नीचे गिरती है और तालिका के निचले टुकड़ों को पता होना चाहिए कि शीर्ष पर क्या है।

भंडारण एल्गोरिथ्म प्रदर्शन

परीक्षण के लिए, आम और AI 0 पर भी #define डिबग सेट करें।
मुझे ऐसा परिणाम मिला - 10FPS जब सभी 619200 क्षेत्रों का प्रतिपादन और प्रसंस्करण,
120 हजार फ़ील्ड पर (25fps)

बॉट लॉजिक

लॉजिक बहुत खराब है , बॉट एक मिनट में जल जाता है, और 60 अंक तक हो जाता है।

मैं कई चक्रों के साथ एक अच्छा तर्क शुरू नहीं कर सका जिसमें छेद और लीड्स और दहनशील क्षेत्र की जांच हो, सभी संभव स्थितियों के आधार पर सबसे अच्छी स्थिति पर विचार ...
अच्छे तर्क ने मेरे लिए 100 प्रतियों तक काम किया और सभी चक्रों को दरकिनार करते हुए एक मजबूत अंतराल दिया।

मेरा बॉट लॉजिक इस तरह काम करता है
सभी तर्क बफ़र ए में फ़ंक्शन AI_pos_gen में है, इसकी दस लाइनें हैं।

छद्म कोड:
ब्लॉक स्थापना के लिए चेक ऊंचाई वर्तमान कॉलम में फ़ील्ड के लिए अधिकतम के बराबर है (ऊंचाई के लिए एक पंक्ति की जांच करें)

 (4   ){ (  (10)){ (     ){  (    ,  )   best ID()  best POS } } }  (     )   (  )      0     1 

यह तीन चक्रों को बताता है जो सामान्य हैं - उन्होंने ब्लॉक लगाया ताकि ऊंचाई कम से कम हो।

AI_pos_gen फ़ंक्शन को तब बुलाया जाता है जब एक नया ब्लॉक दिखाई देता है, और ऊपर से गिरने के लिए स्थिति लौटाता है , ब्लॉक आईडी ले रहा है और इसे घुमाता है, फ़ंक्शन तीसरे पिक्सेल (तर्क) में काम करता है, अर्थात इसमें पूर्ण लोड किया गया नक्शा (नक्शा सरणी) है।
आप चाहें तो आसानी से अपने बॉट को लिखने की कोशिश कर सकते हैं।

सबसे धीमी जगह
छेदों का परीक्षण करने के लिए सिर्फ एक लूप जोड़ने से, मेरा वीडियो कार्ड चालक दुर्घटनाग्रस्त हो गया जब बॉट की संख्या 10 हजार से अधिक थी ... मैंने जो बॉट लिखा था वह बॉट का सबसे "न्यूनतर" संस्करण है जो मैं कर सकता था, और यह दुर्भाग्य से बहुत बुरा है।

यूआई इंटरफ़ेस / प्रतिपादन

छवि में सभी प्रतिपादन, बफ़र में UI तर्क ।

प्रतिपादन:
स्क्रीन को टाइलों में विभाजित करना और प्रत्येक टाइल में एक टेबल खींचना, न्यूनतम लोड।

मानचित्र लोड करने का तर्क - प्रत्येक पिक्सेल अनपैक्ड नहीं है, प्रत्येक पिक्सेल अनपैक किया गया है, केवल "आवश्यक बिट" अनपैक किया गया है (शाब्दिक रूप से), फ़ंक्शन कोड है:

 int maptmp(int id, int midg) { int nBits = 8; ivec4 pixeldata = loadat(id, midg); int itt = (id / 24) / 4; //data pixel id 0-2 int jtt = (id - itt * 24 * 4) / 24; //component in data pizel id 0-3 int ott = (id - itt * 24 * 4 - jtt * 24) / 8; //component in unpacked value 0-2 int ttt = (id - itt * 24 * 4 - jtt * 24 - ott * 8); //bit after int2bit 0-7 ivec3 val = decodeval16(pixeldata[jtt]); int n = val[ott]; for (int i = 0; i < nBits; ++i, n /= 2) { if (i == ttt) { if ((n % 2) == 0)return 0; else return 1; //switch + return does not work on windows(Angle) /*switch (n % 2) { case 0:return 0;break; case 1:return 1;break; }*/ } } return 0; } 

स्क्रॉल करने से बचने के लिए , जब स्क्रॉलिंग 43000 से शुरू होती है, फ्लोट का आंशिक हिस्सा खो जाता है, और स्क्रॉल करने के लिए यूवी पर 619 हजार जोड़ने के लिए काम नहीं करता है (तालिकाओं के बजाय पिक्सेल होंगे)।
सभी स्क्रॉलिंग को एक बड़ी टाइल में विभाजित किया जाता है और एक सर्कल में घुमाया जाता है जो यूवी को अधिकतम 32 तक जोड़ता है। ( छवि में लाइन 207)।

फ़ील्ड आईडी निर्धारित करने के लिए भी यही किया जाता है। ( छवि में रेखा 215)

यूआई

संख्या:
पीला टेट्रिस खेतों की संख्या है।
बाएं बड़े - वर्तमान क्षेत्र की संख्या।
निचले दाईं ओर - वर्तमान फ़ील्ड के बिंदु।

स्रोत और लॉन्च

Bufer A लॉजिक, Bufer B UI कंट्रोल, इमेज रेंडरिंग है
Https://www.shadertoy.com/view/3dlSzs पर स्रोत (कोण 16 सेकंड के माध्यम से संकलन समय)
बॉट वहां अक्षम है (आप इसे सक्षम कर सकते हैं), और सभी फ़ील्ड कीबोर्ड से खेलने योग्य हैं।

बायां / दायां / ऊपर / नीचे तीर नियंत्रित करें।

UI लाल आयत रीसेट, ले जाएँ (माउस को LMB पर क्लिक करके खींचें) और फ़ील्ड पर क्लिक करके स्क्रॉल करें या प्रदर्शित करने के लिए फ़ील्ड चुनें।

वेब ब्राउज़र से लॉन्च करें:

• chrome.exe --use-angle = gl के साथ क्रोम चलाएं
• shadertoy के लिंक का अनुसरण करें
• साइट पर संपादक में, सामान्य का चयन करें और #define no_AI को हटाएं
• (आम में भी) #define AI 199 से 0 सेट करें, यानी #define AI 0
• संकलन बटन पर क्लिक करें (shader पर संपादक विंडो के तहत) और फुलस्क्रीन पर क्लिक करें

दूसरा विकल्प किसी भी "shader लॉन्चर" में शेडर को चलाने के लिए है, यहां आर्काइव ( डाउनलोड ) जिसमें * .exe फ़ाइल इस shader के साथ लिंक है ।

10 सेकंड के बारे में OpenGL संकलन समय।

अद्यतन : छेद के साथ एक shader जोड़ा https://www.shadertoy.com/view/wsXXzH
एक ही ऊंचाई पर बेहतर स्थिति के लिए स्थिति के बजाय। फ़ंक्शन check_block_at_wh (लाइन 380 BufA) स्थिति की वैधता की जाँच के साथ-साथ छिद्रों को गिनता है, कोई नया चक्र नहीं जोड़ा गया है, और हालत रेखा 442 से 459 BufA।
यह 30-60 अंक के भीतर एक मिनट में जल्दी से जलता है। (जाहिर है, आपको छेद के लिए एक बड़े क्षेत्र की जांच करने की आवश्यकता है, लेकिन यह मजबूत ब्रेक देता है)

और काम को थोड़ा समझाने वाली दो तस्वीरें:
स्थिति चयन https://i.imgur.com/e0uENgV.png
हालत के लिए ब्लॉक की स्थिति https://i.imgur.com/ORECXUW.png है