📶 🤮 🔟 कैसे मैंने एई को एनईएस के लिए टेट्रिस खेलना सिखाया। भाग 1: खेल कोड का विश्लेषण 👍🏽 🖖🏻 🕺🏿

इस लेख में, मैं निंटेंडो टेट्रिस के भ्रामक सरल यांत्रिकी का पता लगाऊंगा, और दूसरे भाग में मैं समझाऊंगा कि कैसे मैंने एक एआई बनाया जो इन यांत्रिकी का शोषण करता है।

इसे स्वयं आज़माएं

परियोजना के बारे में

उन लोगों के लिए जिनके पास निन्टेंडो टेट्रिस को बनाने के लिए दृढ़ता, धैर्य और समय की कमी है, मैंने एक एआई बनाया जो अपने दम पर खेल सकता है। आप अंत में 30 के स्तर तक पहुंच सकते हैं और आगे भी। आप देखेंगे कि अधिकतम अंक कैसे प्राप्त करें और पंक्ति काउंटरों, स्तरों और आँकड़ों के अंतहीन परिवर्तन का निरीक्षण करें। आप सीखेंगे कि कौन से रंग ऊपर के स्तर पर दिखाई देते हैं, जिस पर कोई व्यक्ति चढ़ नहीं सकता है। देखें कि आप कितनी दूर जा सकते हैं।

आवश्यकताओं

एआई चलाने के लिए, आपको एक सार्वभौमिक एनईएस / फेमीकॉम एफसीईएक्स एमुलेटर की आवश्यकता है । आर्टिफिशियल इंटेलिजेंस को FCEUX 2.2.2 के लिए विकसित किया गया था, जो लिखने के समय एमुलेटर का सबसे नया संस्करण था।

आपको निन्टेंडो टेट्रिस रॉम फ़ाइल (यूएस संस्करण) की भी आवश्यकता होगी। इसे Google पर खोजने का प्रयास करें।

डाउनलोड

इस स्रोत ज़िप फ़ाइल से अनज़िप lua/NintendoTetrisAI.lua ।

लांच

FCEUX लॉन्च करें। मेनू से, फ़ाइल का चयन करें | ओपन रोम ... ओपन फाइल डायलॉग बॉक्स में, निनटेंडो टेट्रिस रोम फाइल को चुनें और ओपन पर क्लिक करें। खेल शुरू हो जाएगा।

मेनू से, फ़ाइल का चयन करें | लुआ | नई लुआ स्क्रिप्ट विंडो ... लुआ स्क्रिप्ट विंडो में, NintendoTetrisAI.lua लिए पथ दर्ज करें या इसे खोजने के लिए ब्राउज़ बटन पर क्लिक करें। उसके बाद, Run पर क्लिक करें।

Lua की स्क्रिप्ट आपको मेनू की पहली स्क्रीन पर पुनर्निर्देशित करेगी। खेल A- प्रकार का खेल छोड़ दें, और आप कोई भी संगीत चुन सकते हैं। धीमे कंप्यूटर पर, संगीत बहुत झटके से खेल सकता है, फिर आपको इसे बंद कर देना चाहिए। अगली मेनू स्क्रीन पर जाने के लिए स्टार्ट (एंटर) दबाएँ। दूसरे मेनू में, आप प्रारंभ स्तर को बदलने के लिए तीर कुंजियों का उपयोग कर सकते हैं। गेम शुरू करने के लिए स्टार्ट पर क्लिक करें। और यहाँ AI नियंत्रण करेगा।

यदि दूसरी मेनू स्क्रीन पर एक स्तर का चयन करने के बाद, गेमपैड बटन A को दबाए रखें (आप कॉन्फ़िगरेशन में कीबोर्ड लेआउट बदल सकते हैं। इनपुट ... मेनू) और प्रारंभ दबाएं, फिर प्रारंभिक स्तर चयनित मूल्य से 10 अधिक होगा। अधिकतम प्रवेश स्तर उन्नीसवां है।

विन्यास

खेल को तेज़ी से चलाने के लिए, एक पाठ संपादक में Lua स्क्रिप्ट खोलें। फ़ाइल की शुरुआत में, निम्न पंक्ति ढूंढें।

PLAY_FAST = false

नीचे दिखाए गए अनुसार true साथ false बदलें।

PLAY_FAST = true

फ़ाइल सहेजें। इसके बाद Lua Script विंडो में रिस्टार्ट बटन पर क्लिक करें।

निनटेंडो टेट्रिस मैकेनिक्स

टेट्रिमिनो का विवरण

प्रत्येक टेट्रीमिनो आकृति एक अक्षर के नाम से मेल खाती है जो इसके आकार से मिलता जुलता है।

निन्टेंडो टेट्रिस डिजाइनर मनमाने ढंग से ऊपर दिखाए गए टेट्रीमिनो क्रम को सेट करते हैं। आंकड़े उस अभिविन्यास में दिखाए जाते हैं जिसमें वे स्क्रीन पर दिखाई देते हैं, और सर्किट लगभग सममित चित्र बनाता है (शायद यही कारण है कि यह आदेश चुना गया है)। अनुक्रम सूचकांक प्रत्येक टेट्रीमिनो को एक अद्वितीय संख्यात्मक आईडी देता है। प्रोग्रामिंग स्तर पर अनुक्रम और प्रकार पहचानकर्ता महत्वपूर्ण हैं; इसके अलावा, वे आंकड़े क्षेत्र में प्रदर्शित आंकड़ों के क्रम में खुद को प्रकट करते हैं (नीचे देखें)।

निंटेंडो टेट्रिस टेट्रीमिनो में उपयोग किए जाने वाले 19 झुकाव एनईएस कंसोल मेमोरी के $8A9C पर स्थित तालिका में एन्कोड किए गए हैं। प्रत्येक आकृति को 12 बाइट्स के अनुक्रम के रूप में दर्शाया जाता है जिसे त्रिकोणीय (Y, tile, X) में विभाजित किया जा सकता है जो आंकड़े में प्रत्येक वर्ग का वर्णन करते हैं। $7F ऊपर के निर्देशांक के उपरोक्त हेक्स-मान नकारात्मक पूर्णांक ( $FF= −1 , $FF= −1 , और $FE = −2 ) को दर्शाते हैं।

; Y0 T0 X0 Y1 T1 X1 Y2 T2 X2 Y3 T3 X3

8A9C: 00 7B FF 00 7B 00 00 7B 01 FF 7B 00 ; 00: T up
8AA8: FF 7B 00 00 7B 00 00 7B 01 01 7B 00 ; 01: T right
8AB4: 00 7B FF 00 7B 00 00 7B 01 01 7B 00 ; 02: T down (spawn)
8AC0: FF 7B 00 00 7B FF 00 7B 00 01 7B 00 ; 03: T left

8ACC: FF 7D 00 00 7D 00 01 7D FF 01 7D 00 ; 04: J left
8AD8: FF 7D FF 00 7D FF 00 7D 00 00 7D 01 ; 05: J up
8AE4: FF 7D 00 FF 7D 01 00 7D 00 01 7D 00 ; 06: J right
8AF0: 00 7D FF 00 7D 00 00 7D 01 01 7D 01 ; 07: J down (spawn)

8AFC: 00 7C FF 00 7C 00 01 7C 00 01 7C 01 ; 08: Z horizontal (spawn)
8B08: FF 7C 01 00 7C 00 00 7C 01 01 7C 00 ; 09: Z vertical

8B14: 00 7B FF 00 7B 00 01 7B FF 01 7B 00 ; 0A: O (spawn)

8B20: 00 7D 00 00 7D 01 01 7D FF 01 7D 00 ; 0B: S horizontal (spawn)
8B2C: FF 7D 00 00 7D 00 00 7D 01 01 7D 01 ; 0C: S vertical

8B38: FF 7C 00 00 7C 00 01 7C 00 01 7C 01 ; 0D: L right
8B44: 00 7C FF 00 7C 00 00 7C 01 01 7C FF ; 0E: L down (spawn)
8B50: FF 7C FF FF 7C 00 00 7C 00 01 7C 00 ; 0F: L left
8B5C: FF 7C 01 00 7C FF 00 7C 00 00 7C 01 ; 10: L up

8B68: FE 7B 00 FF 7B 00 00 7B 00 01 7B 00 ; 11: I vertical
8B74: 00 7B FE 00 7B FF 00 7B 00 00 7B 01 ; 12: I horizontal (spawn)

8B80: 00 FF 00 00 FF 00 00 FF 00 00 FF 00 ; 13: Unused

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

पढ़ने में आसानी के लिए, दशमलव में वर्गों के निर्देशांक नीचे दिखाए गए हैं।

-- { { X0, Y0 }, { X1, Y1 }, { X2, Y2 }, { X3, Y3 }, },

{ { -1, 0 }, { 0, 0 }, { 1, 0 }, { 0, -1 }, }, -- 00: T up
{ { 0, -1 }, { 0, 0 }, { 1, 0 }, { 0, 1 }, }, -- 01: T right
{ { -1, 0 }, { 0, 0 }, { 1, 0 }, { 0, 1 }, }, -- 02: T down (spawn)
{ { 0, -1 }, { -1, 0 }, { 0, 0 }, { 0, 1 }, }, -- 03: T left

{ { 0, -1 }, { 0, 0 }, { -1, 1 }, { 0, 1 }, }, -- 04: J left
{ { -1, -1 }, { -1, 0 }, { 0, 0 }, { 1, 0 }, }, -- 05: J up
{ { 0, -1 }, { 1, -1 }, { 0, 0 }, { 0, 1 }, }, -- 06: J right
{ { -1, 0 }, { 0, 0 }, { 1, 0 }, { 1, 1 }, }, -- 07: J down (spawn)

{ { -1, 0 }, { 0, 0 }, { 0, 1 }, { 1, 1 }, }, -- 08: Z horizontal (spawn)
{ { 1, -1 }, { 0, 0 }, { 1, 0 }, { 0, 1 }, }, -- 09: Z vertical

{ { -1, 0 }, { 0, 0 }, { -1, 1 }, { 0, 1 }, }, -- 0A: O (spawn)

{ { 0, 0 }, { 1, 0 }, { -1, 1 }, { 0, 1 }, }, -- 0B: S horizontal (spawn)
{ { 0, -1 }, { 0, 0 }, { 1, 0 }, { 1, 1 }, }, -- 0C: S vertical

{ { 0, -1 }, { 0, 0 }, { 0, 1 }, { 1, 1 }, }, -- 0D: L right
{ { -1, 0 }, { 0, 0 }, { 1, 0 }, { -1, 1 }, }, -- 0E: L down (spawn)
{ { -1, -1 }, { 0, -1 }, { 0, 0 }, { 0, 1 }, }, -- 0F: L left
{ { 1, -1 }, { -1, 0 }, { 0, 0 }, { 1, 0 }, }, -- 10: L up

{ { 0, -2 }, { 0, -1 }, { 0, 0 }, { 0, 1 }, }, -- 11: I vertical
{ { -2, 0 }, { -1, 0 }, { 0, 0 }, { 1, 0 }, }, -- 12: I horizontal (spawn)

सभी झुकाव 5 × 5 मैट्रिक्स में रखे गए हैं।

ऊपर के आंकड़े में, सफेद वर्ग मैट्रिक्स के केंद्र को इंगित करता है, आकृति के रोटेशन के लिए संदर्भ बिंदु।

अभिविन्यास तालिका रेखांकन नीचे प्रस्तुत की गई है।

ओरिएंटेशन आइडेंटिफायर (टेबल इंडेक्स) प्रत्येक मैट्रिक्स के ऊपरी दाएं कोने में हेक्साडेसिमल में दिखाया गया है। और इस परियोजना के लिए आविष्कार किए गए mnemonics को ऊपरी बाएं कोने में दिखाया गया है। u , r , d , l , h और v "ऊपर, दाएं, नीचे, बाएं, क्षैतिज और ऊर्ध्वाधर" के संक्षिप्त रूप हैं। उदाहरण के लिए, $07 बजाय Jd के अभिविन्यास को निरूपित करना आसान है।

निर्माण के दौरान आकृतियों के झुकावों वाले मैट्रिक्स को एक सफेद फ्रेम के साथ चिह्नित किया गया है।

टेट्रीमिनो I, S और Z को 4 अलग-अलग झुकाव दिए जा सकते हैं, लेकिन निन्टेंडो टेट्रिस के रचनाकारों ने खुद को दो तक सीमित रखने का फैसला किया। इसके अलावा, Zv और Sv एक दूसरे के आदर्श दर्पण चित्र नहीं हैं। दोनों वामावर्त मोड़ द्वारा बनाए गए हैं, जो एक असंतुलन की ओर जाता है।

अभिविन्यास तालिका में प्रत्येक उन्मुख आकृति में प्रत्येक वर्ग के लिए टाइल मान शामिल हैं। हालांकि, एक सावधानीपूर्वक अध्ययन के साथ, यह स्पष्ट हो जाता है कि टेट्रीमिनो के एक प्रकार के मूल्य हमेशा समान होते हैं।

टी	जम्मू	जेड	हे	एस	एल	मैं
`7B`	`7D`	`7C`	`7B`	`7D`	`7C`	`7B`

टाइल मान नीचे दिखाए गए पैटर्न के (छद्म रंग) तालिका के सूचक हैं।

$7B , $7C और $7D टाइलें "सांख्यिकी" शब्द से सीधे "ATIS" के नीचे स्थित हैं। ये तीन प्रकार के वर्ग हैं जिनसे टेट्रीमिनो बनाया जाता है।

जिज्ञासु के लिए, मेरा कहना है कि बी-टाइप मोड के अंत में शुतुरमुर्ग और पेंगुइन का उपयोग किया जाता है। इस विषय पर "एंडिंग" अनुभाग में विस्तार से चर्चा की गई है।

नीचे $7B जगह $29 बाद ROM को संशोधित करने का परिणाम है। दिल सभी झुकाव टी के लिए पैटर्न तालिका में पी प्रतीक के तहत टाइल है।

जगह में ताला लगा होने के बाद भी दिल की दीवारें खेल के मैदान में बनी रहती हैं। जैसा कि "क्रिएट टेट्रिमिनो" सेक्शन में कहा गया है, इसका मतलब है कि खेल का मैदान टेट्रिमिनो के टाइल सूचकांकों के वास्तविक मूल्यों को संग्रहीत करता है।

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

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

8A9C: FE 7B FE FE 7B 02 02 7B FE 02 7B 02 ; 00: T up

यह परिवर्तन निम्नलिखित के समान है:

{ { -2, -2 }, { 2, -2 }, { -2, 2 }, { 2, 2 }, }, -- 00: T up

परिणाम एक विभाजन टेट्रिमिनो है।

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

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

गेम किसी भी सामान्य आकृति की तरह स्प्लिट टेट्रिमिनस को संभालता है। इससे हमें समझ में आता है कि आंकड़ों की मेटाडेटा को संग्रहीत करने वाली कोई अतिरिक्त तालिका नहीं है। उदाहरण के लिए, खेल के मैदान की परिधि के साथ टकराव के लिए जाँच करने के लिए प्रत्येक अभिविन्यास के बाउंडिंग बॉक्स के आकार को संग्रहीत करने वाली एक तालिका हो सकती है। लेकिन ऐसी तालिका का उपयोग नहीं किया जाता है। इसके बजाय, खेल आकार में हेरफेर करने से ठीक पहले सभी चार वर्गों की जांच करता है।

इसके अलावा, वर्गों के निर्देशांक किसी भी मूल्य हो सकते हैं; वे अंतराल [−2, 2] तक सीमित नहीं हैं। बेशक, इस अंतराल से बहुत अधिक मूल्य हमें अनुचित आंकड़े देंगे जो खेल के मैदान पर फिट नहीं हो सकते। अधिक महत्वपूर्ण रूप से, जैसा कि अनुभाग में कहा गया है "गेम स्टेट्स और रेंडरिंग मोड्स", जब कोई आंकड़ा जगह में बंद हो जाता है, तो भरी लाइनों को साफ करने का तंत्र केवल आंकड़े के केंद्रीय वर्ग से −2 से 1 तक पंक्तियों के विस्थापन को स्कैन करता है; इस अंतराल के बाहर y समन्वय वाला एक वर्ग बिना मान्यता वाला होगा।

टेट्रिमिनो रोटेशन

अभिविन्यास तालिका के एक ग्राफिक चित्रण में, रोटेशन में मैट्रिक्स से बाईं ओर या दाईं ओर से एक मैट्रिसेस को श्रृंखला में स्थानांतरित करने के लिए आवश्यक होने पर स्थानांतरित करना शामिल है। यह अवधारणा $88EE में एक तालिका में एन्कोडेड है।

; CCW CW
88EE: 03 01 ; Tl Tr
88F0: 00 02 ; Tu Td
88F2: 01 03 ; Tr Tl
88F4: 02 00 ; Td Tu
88F6: 07 05 ; Jd Ju
88F8: 04 06 ; Jl Jr
88FA: 05 07 ; Ju Jd
88FC: 06 04 ; Jr Jl
88FE: 09 09 ; Zv Zv
8900: 08 08 ; Zh Zh
8902: 0A 0A ; OO
8904: 0C 0C ; Sv Sv
8906: 0B 0B ; Sh Sh
8908: 10 0E ; Lu Ld
890A: 0D 0F ; Lr Ll
890C: 0E 10 ; Ld Lu
890E: 0F 0D ; Ll Lr
8910: 12 12 ; Ih Ih
8912: 11 11 ; Iv Iv

इसे स्पष्ट करने के लिए, हम इस तालिका से प्रत्येक तालिका को नीचे दी गई तालिका की पंक्ति में ले जाएंगे।

	`Tu`	`Tr`	`Td`	`Tl`	`Jl`	`Ju`	`Jr`	`Jd`	`Zh`	`Zv`	`O`	`Sh`	`Sv`	`Lr`	`Ld`	`Ll`	`Lu`	`Iv`	`Ih`
घड़ी की विपरीत दिशा	`Tl`	`Tu`	`Tr`	`Td`	`Jd`	`Jl`	`Ju`	`Jr`	`Zv`	`Zh`	`O`	`Sv`	`Sh`	`Lu`	`Lr`	`Ld`	`Ll`	`Ih`	`Iv`
दक्षिणावर्त	`Tr`	`Td`	`Tl`	`Tu`	`Ju`	`Jr`	`Jd`	`Jl`	`Zv`	`Zh`	`O`	`Sv`	`Sh`	`Ld`	`Ll`	`Lu`	`Lr`	`Ih`	`Iv`

उपर्युक्त शीर्षकों में वर्णक्रमीयता की व्याख्या अनुक्रम सूचकांक या वितरण कुंजी के रूप में की जा सकती है। उदाहरण के लिए, वामावर्त Tu को Tl हमें Tl देता है, और दक्षिणावर्त Tu को Tr देता है।

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

रोटेशन टेबल के सामने इसे एक्सेस करने के लिए एक कोड है।

88AB: LDA $0042
88AD: STA $00AE ; originalOrientationID = orientationID;

88AF: CLC
88B0: LDA $0042
88B2: ASL
88B3: TAX ; index = 2 * orientationID;

88B4: LDA $00B5
88B6: AND #$80 ; if (not just pressed button A) {
88B8: CMP #$80 ; goto aNotPressed;
88BA: BNE $88CF ; }

88BC: INX
88BD: LDA $88EE,X
88C0: STA $0042 ; orientationID = rotationTable[index + 1];

88C2: JSR $948B ; if (new orientation not valid) {
88C5: BNE $88E9 ; goto restoreOrientationID;
; }

88C7: LDA #$05
88C9: STA $06F1 ; play rotation sound effect;
88CC: JMP $88ED ; return;

aNotPressed:

88CF: LDA $00B5
88D1: AND #$40 ; if (not just pressed button B) {
88D3: CMP #$40 ; return;
88D5: BNE $88ED ; }

88D7: LDA $88EE,X
88DA: STA $0042 ; orientationID = rotationTable[index];

88DC: JSR $948B ; if (new orientation not valid) {
88DF: BNE $88E9 ; goto restoreOrientationID;
; }

88E1: LDA #$05
88E3: STA $06F1 ; play rotation sound effect;
88E6: JMP $88ED ; return;

restoreOrientationID:

88E9: LDA $00AE
88EB: STA $0042 ; orientationID = originalOrientationID;

88ED: RTS ; return;

वामावर्त घुमाव के लिए, अभिविन्यास आईडी को दोगुना करके रोटेशन तालिका के सूचकांक को घटाया जाता है। इसमें 1 जोड़ने से हमें क्लॉकवाइज रोटेशन इंडेक्स मिलता है।

वर्तमान tetrimino के x , y निर्देशांक और अभिविन्यास आईडी को क्रमशः $0040 , $0041 और $0042 के पते पर संग्रहीत किया जाता है।

कोड उन्मुखीकरण आईडी का बैकअप लेने के लिए एक अस्थायी चर का उपयोग करता है। बाद में, अभिविन्यास बदलने के बाद, कोड पुष्टि करता है कि सभी चार वर्ग खेल के मैदान की सीमाओं के भीतर हैं और उनमें से कोई भी पहले से ही झूठे वर्गों को ओवरलैप नहीं करता है (सत्यापन कोड $948B पर स्थित है, ऊपर दिखाए गए कोड टुकड़े के तहत)। यदि नया अभिविन्यास गलत है, तो मूल एक को बहाल किया जाता है, खिलाड़ी को आंकड़े को घुमाने की अनुमति नहीं देता है।

एक क्रॉस के साथ गणना करते हुए, एनईएस नियंत्रक में आठ बटन होते हैं, जिनमें से स्थिति का पता बिट $00B6 द्वारा $00B6 ।

`7`	`6`	`5`	`4`	`3`	`2`	`1`	`0`
एक	बी	चुनना	प्रारंभ	ऊपर	नीचे	बाईं ओर	दाईं ओर

उदाहरण के लिए, $00B6 में मूल्य $81 जबकि खिलाड़ी A और Left को रखता है।

दूसरी ओर, बटन दबाए जाने पर $00B5 रिपोर्ट; बिट्स $00B5 केवल गेम लूप (1 रेंडर फ्रेम) के एक पुनरावृत्ति के दौरान सही हैं। A और B दबाने पर प्रतिक्रिया देने के लिए कोड $00B5 का उपयोग करता है और उनमें से प्रत्येक को फिर से उपयोग किए जाने से पहले जारी करने की आवश्यकता होती है।

$00B5 और $00B6 $00B5 और $00B6 दर्पण हैं। निम्नलिखित अनुभागों में कोड इन पतों का परस्पर उपयोग करता है।

Tetrimino बनाएँ

निन्टेंडो टेट्रिस खेल मैदान में 22 पंक्तियों और 10 स्तंभों के साथ एक मैट्रिक्स होता है ताकि शीर्ष दो पंक्तियों को खिलाड़ी से छिपाया जाए।

जैसा कि नीचे दिए गए कोड में दिखाया गया है, एक टेट्रिमिनो आंकड़ा बनाते समय, यह हमेशा खेल के मैदान के निर्देशांक (5, 0) ।

98BA: LDA #$00
98BC: STA $00A4
98BE: STA $0045
98C0: STA $0041 ; Tetrimino Y = 0
98C2: LDA #$01
98C4: STA $0048
98C6: LDA #$05
98C8: STA $0040 ; Tetrimino X = 5

नीचे इस बिंदु पर 5 × 5 मैट्रिक्स सुपरिम्पोज किया गया है।

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

आमतौर पर हम सोचते हैं कि खेल समाप्त होता है जब ढेर शीर्ष पर पहुंचता है। लेकिन वास्तव में, यह पूरी तरह से सच नहीं है। खेल तब समाप्त होता है जब अगले टुकड़े को बनाना संभव नहीं होता। यही है, आकृति की उपस्थिति से पहले, बनाए गए टेट्रिमिनो के वर्गों के पदों के अनुरूप खेल मैदान के सभी चार कोशिकाएं मुक्त होनी चाहिए। चित्र को इस तरह से लॉक किया जा सकता है कि इसके वर्गों का हिस्सा नकारात्मक रूप से गिने लाइनों में प्रकट होता है, और खेल समाप्त नहीं होता है; हालांकि, निन्टेंडो टेट्रिस में, नकारात्मक रेखाएं केवल सक्रिय टेट्रीमिनो से संबंधित एक अमूर्तता हैं। आंकड़ा अवरुद्ध होने (झूठ बोलने के बाद) के बाद, शून्य से लाइनों में केवल वर्ग और अधिक को फ़ील्ड में लिखा जाता है। वैचारिक रूप से, यह पता चला है कि नकारात्मक रूप से गिने लाइनें स्वचालित रूप से अवरुद्ध होने के बाद साफ हो जाती हैं। लेकिन वास्तव में, खेल केवल आंकड़ों के ऊपरी हिस्सों को काटकर, इस डेटा को संग्रहीत नहीं करता है।

खेल के मैदान का दृश्य क्षेत्र 20 × 10 लाइन द्वारा $0400 लाइन पर संग्रहीत किया जाता है, प्रत्येक बाइट में पृष्ठभूमि टाइल का मूल्य होता है। खाली कोशिकाओं को $EF टाइल, एक ठोस काले वर्ग द्वारा निरूपित किया जाता है।

आकार बनाते समय, तीन लुकअप तालिकाओं का उपयोग किया जाता है। यदि एक मनमाना अभिविन्यास आईडी है, तो $9956 पर तालिका हमें इसी प्रकार की टेट्रिमिनो बनाते समय अभिविन्यास आईडी प्रदान करती है।

9956: 02 02 02 02 ; Td
995A: 07 07 07 07 ; Jd
995E: 08 08 ; Zh
9960: 0A ; O
9961: 0B 0B ; Sh
9963: 0E 0E 0E 0E ; Ld
9967: 12 12 ; Ih

इसे तालिका में दिखाना आसान है।

`Tu`	`Tr`	`Td`	`Tl`	`Jl`	`Ju`	`Jr`	`Jd`	`Zh`	`Zv`	`O`	`Sh`	`Sv`	`Lr`	`Ld`	`Ll`	`Lu`	`Iv`	`Ih`
`Td`	`Td`	`Td`	`Td`	`Jd`	`Jd`	`Jd`	`Jd`	`Zh`	`Zh`	`O`	`Sh`	`Sh`	`Ld`	`Ld`	`Ld`	`Ld`	`Ih`	`Ih`

उदाहरण के लिए, J की सभी अभिविन्यास Jd जुड़ी हुई हैं।

$993B की तालिका में दी गई अभिविन्यास आईडी के लिए Tetrimino प्रकार है।

993B: 00 00 00 00 ; T
993F: 01 01 01 01 ; J
9943: 02 02 ; Z
9945: 03 ; O
9946: 04 04 ; S
9948: 05 05 05 05 ; L
994C: 06 06 ; I

स्पष्टता के लिए, मैं सब कुछ सारणीबद्ध रूप में दिखाऊंगा।

`Tu`	`Tr`	`Td`	`Tl`	`Jl`	`Ju`	`Jr`	`Jd`	`Zh`	`Zv`	`O`	`Sh`	`Sv`	`Lr`	`Ld`	`Ll`	`Lu`	`Iv`	`Ih`
`T`	`T`	`T`	`T`	`J`	`J`	`J`	`J`	`Z`	`Z`	`O`	`S`	`S`	`L`	`L`	`L`	`L`	`I`	`I`

हम अगले खंड में तीसरी खोज तालिका देखेंगे।

टेट्रिमिनो चयन

निन्टेंडो टेट्रिस अपने फाइबोनैचि विन्यास में छद्म-यादृच्छिक संख्या जनरेटर (PRNG) के रूप में 16-बिट रैखिक प्रतिक्रिया पारी रजिस्टर (LFSR) का उपयोग करता है। 16-बिट मान को $0017 - $0018 के पते पर बड़े-एंडियन के रूप में संग्रहीत किया जाता है। $8988 की एक मनमानी बीज के रूप $8988 उपयोग की जाती है।

80BC: LDX #$89
80BE: STX $0017
80C0: DEX
80C1: STX $0018

प्रत्येक अनुवर्ती छद्म-यादृच्छिक संख्या निम्नानुसार उत्पन्न होती है: मान को 17-बिट संख्या के रूप में माना जाता है, और बिट 1 और 9 के लिए XOR प्रदर्शन करके सबसे महत्वपूर्ण बिट प्राप्त किया जाता है। फिर मूल्य को दाईं ओर स्थानांतरित कर दिया जाता है, कम से कम महत्वपूर्ण बिट को त्याग दिया जाता है।

यह प्रक्रिया $AB47 होती है।

AB47: LDA $00,X
AB49: AND #$02
AB4B: STA $0000 ; extract bit 1

AB4D: LDA $01,X
AB4F: AND #$02 ; extract bit 9

AB51: EOR $0000
AB53: CLC
AB54: BEQ $AB57
AB56: SEC ; XOR bits 1 and 9 together

AB57: ROR $00,X
AB59: INX
AB5A: DEY ; right shift
AB5B: BNE $AB57 ; shifting in the XORed value

AB5D: RTS ; return

दिलचस्प बात यह है कि उपरोक्त सबरूटीन के मापदंडों को सेट किया जा सकता है ताकि कॉलिंग फ़ंक्शन शिफ्ट रजिस्टर की चौड़ाई और उस पते को निर्दिष्ट कर सके जिस पर इसे मेमोरी में पाया जा सकता है। हालांकि, हर जगह समान पैरामीटर का उपयोग किया जाता है, इसलिए हम यह मान सकते हैं कि डेवलपर्स ने इस कोड को कहीं उधार लिया है।

उन लोगों के लिए जो एल्गोरिथ्म को और संशोधित करना चाहते हैं, मैंने इसे जावा में लिखा है।

 int generateNextPseudorandomNumber(int value) { int bit1 = (value >> 1) & 1; int bit9 = (value >> 9) & 1; int leftmostBit = bit1 ^ bit9; return (leftmostBit << 15) | (value >> 1); }

और यह सब कोड एक पंक्ति में निचोड़ा जा सकता है।

 int generateNextPseudorandomNumber(int value) { return ((((value >> 9) & 1) ^ ((value >> 1) & 1)) << 15) | (value >> 1); }

यह PRNG लगातार और नियतात्मक रूप से मूल बीज से प्रत्येक चक्र को शुरू करते हुए, 32,767 अद्वितीय मान उत्पन्न करता है। यह संभावित संख्या के आधे से भी कम है जो रजिस्टर में फिट हो सकता है, और इस सेट में किसी भी मूल्य को बीज के रूप में इस्तेमाल किया जा सकता है। सेट के बाहर कई मान एक श्रृंखला बनाते हैं जो अंततः सेट से एक संख्या की ओर ले जाती है। हालाँकि, कुछ प्रारंभिक संख्याओं का परिणाम शून्य के अनंत क्रम में होता है।

मोटे तौर पर इस PRNG के प्रदर्शन का मूल्यांकन करने के लिए, मैंने RANDOM .ORG के साथ एक वाक्य के आधार पर बनाए गए मूल्यों का चित्रमय प्रतिनिधित्व किया।

छवि बनाते समय, PRNG को 16-बिट पूर्णांक के बजाय एक छद्म यादृच्छिक संख्या जनरेटर के रूप में उपयोग किया गया था। प्रत्येक पिक्सेल बिट 0. के मान के आधार पर रंगीन होता है। छवि का आकार 128 × 256 है, अर्थात यह पूरे अनुक्रम को कवर करता है।

ऊपरी और बाएं तरफ बमुश्किल ध्यान देने योग्य धारियों के अलावा, यह यादृच्छिक दिखता है। कोई स्पष्ट पैटर्न दिखाई नहीं देता है।

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

आकृति के निर्माण के दौरान, $9907 के कोड $9907 , नए आंकड़े के प्रकार को चुनते हुए।

9907: INC $001A ; spawnCount++;

9909: LDA $0017 ; index = high byte of randomValue;

990B: CLC
990C: ADC $001A ; index += spawnCount;

990E: AND #$07 ; index &= 7;

9910: CMP #$07 ; if (index == 7) {
9912: BEQ $991C ; goto invalidIndex;
; }

9914: TAX
9915: LDA $994E,X ; newSpawnID = spawnTable[index];

9918: CMP $0019 ; if (newSpawnID != spawnID) {
991A: BNE $9938 ; goto useNewSpawnID;
; }

invalidIndex:

991C: LDX #$17
991E: LDY #$02
9920: JSR $AB47 ; randomValue = generateNextPseudorandomNumber(randomValue);

9923: LDA $0017 ; index = high byte of randomValue;

9925: AND #$07 ; index &= 7;

9927: CLC
9928: ADC $0019 ; index += spawnID;

992A: CMP #$07
992C: BCC $9934
992E: SEC
992F: SBC #$07
9931: JMP $992A ; index %= 7;

9934: TAX
9935: LDA $994E,X ; newSpawnID = spawnTable[index];

useNewSpawnID:

9938: STA $0019 ; spawnID = newSpawnID;

993A: RTS ; return;

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

दिनचर्या छद्म यादृच्छिक संख्या ( $0017 ) के सबसे महत्वपूर्ण बाइट को टेट्रिमिनो प्रकार में परिवर्तित करता है और इसे आकार निर्माण अभिविन्यास आईडी के रूप में परिवर्तित करने के लिए $994E पर स्थित तालिका के सूचकांक के रूप में उपयोग करता है।

994E: 02 ; Td
994F: 07 ; Jd
9950: 08 ; Zh
9951: 0A ; O
9952: 0B ; Sh
9953: 0E ; Ld
9954: 12 ; Ih

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

चूंकि प्रोसेसर शेष के साथ विभाजन का समर्थन नहीं करता है, इसलिए इस ऑपरेटर को बार-बार 7 घटाकर तब तक अनुकरण किया जाता है जब तक कि परिणाम 7. से कम नहीं हो जाता है। शेष के साथ डिवीजन ऊपरी बाइट के योग पर लागू मुखौटा और पिछले आकार निर्माण अभिविन्यास आईडी के साथ लागू होता है। इस राशि का अधिकतम मूल्य 25 है। अर्थात, इसे शेष 4 तक कम करने के लिए, केवल 3 पुनरावृत्तियों की आवश्यकता है।

प्रत्येक खेल की शुरुआत में, आकार निर्माण अभिविन्यास आईडी ( $0019 ) को Tu ( $00 ) के मूल्य के साथ आरंभीकृत किया जाता है। यह मूल्य संभवतः पहले आकार के निर्माण के दौरान $9928 में इस्तेमाल किया जा सकता है।

पिछले प्रकार के बजाय एक आकृति बनाने के लिए पिछली अभिविन्यास आईडी का उपयोग करते समय, Tetrimino विरूपण जोड़ता है, क्योंकि अभिविन्यास आईडी के मान समान रूप से वितरित नहीं किए जाते हैं। यह तालिका में दिखाया गया है:

$ 00	`$02`	`$07`	`$08`	`$0A`	`$0B`	`$0E`	`$12`
0	2	0	1	3	4	0	4
1	3	1	2	4	5	1	5
2	4	2	3	5	6	2	6
3	5	3	4	6	0	3	0
4	6	4	5	0	1	4	1
5	0	5	6	1	2	5	2
6	1	6	0	2	3	6	3
7	2	0	1	3	4	0	4

प्रत्येक सेल में एक टेट्रीमिनो प्रकार होता है, जो 3 या बिट मूल्य (पंक्ति) के लिए बनाई गई आकृति (स्तंभ) की अभिविन्यास आईडी को जोड़कर गणना की जाती है, और फिर 7 से विभाजित होने के शेष को लागू करने के लिए। प्रत्येक पंक्ति में डुप्लिकेट होते हैं, क्योंकि $07 और $0E समान रूप से विभाजित होते हैं। 7 से, जबकि $0B और $12 में एक सामान्य संतुलन है। लाइनें 0 और 7 समान हैं क्योंकि वे 7 की दूरी पर हैं।

56 संभावित इनपुट संयोजन हैं, और यदि परिणामी टेट्रीमिनो प्रकार समान रूप से वितरित किए जाते हैं, तो हम उम्मीद कर सकते हैं कि ऊपर दी गई तालिका में, प्रत्येक प्रकार ठीक 8 बार दिखाई दे। लेकिन जैसा कि नीचे दिखाया गया है, यह मामला नहीं है।

टाइप	आवृत्ति
टी	9
जम्मू	8
जेड	8
हे	8
एस	9
एल	7
मैं	7

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

मान लीजिए कि PRNG समान रूप से वितरित सांख्यिकीय स्वतंत्र मूल्यों का एक क्रम बनाता है। यह वास्तव में एक उचित धारणा है, यह देखते हुए कि कैसे खेल खिलाड़ी के कार्यों से सही यादृच्छिकता प्राप्त करने की कोशिश करता है। $990C के पते पर निर्मित आंकड़ों की संख्या को जोड़ने से वितरण प्रभावित नहीं होगा, क्योंकि कॉल के बीच संख्या समान रूप से बढ़ जाती है। $990E पर बिटमास्क का उपयोग करना शेष के साथ 8 को विभाजन को लागू करने के समान है, जो वितरण को भी प्रभावित नहीं करता है। इसलिए, सभी मामलों के 1/8 में $9910 जाँच invalidIndex है। और जब $9918 के पते पर जांच करने पर मारने की संभावना है, जहां पिछले आंकड़े के साथ नए चयनित आंकड़े की तुलना 7/8 है, 1/7 के संयोग की संभावना के साथ।इसका मतलब है कि इसमें होने का एक अतिरिक्त मौका 7/8 × 1/7 = 1/8है invalidIndex। सामान्य तौर पर, तिरछे कोड का उपयोग करने की 25% संभावना है और एक कोड का उपयोग करने की 75% संभावना है जो समान रूप से टेट्रीमिनो का चयन करता है।

224 बनाए गए टेट्रिमिनोस के एक सेट में, गणितीय अपेक्षा प्रत्येक प्रकार के लिए 32 उदाहरण हैं। लेकिन वास्तव में कोड निम्नलिखित वितरण बनाता है:

टाइप	आवृत्ति
टी	33
जम्मू	32
जेड	32
हे	32
एस	33
एल	31
मैं	31

यही है, 90 लाइनों को साफ़ करने और 9 के स्तर तक पहुंचने पर, खिलाड़ी को एक अतिरिक्त टी और एस और एक कम एल प्राप्त होगा और मैं सांख्यिकीय रूप से अपेक्षित है।

Tetrimino को निम्नलिखित संभावनाओं के साथ चुना जाता है:

टाइप	संभावना
टी	14.73%
जम्मू	14.29%
जेड	14.29%
हे	14.29%
एस	14.73%
एल	13.84%
मैं	13.84%

ऐसा लगता है कि इस बयान में कि "लंबी छड़ी" मैं कभी नहीं प्रकट होता है जब इसकी आवश्यकता होती है, सच्चाई का हिस्सा होता है (कम से कम पेन्सिलवेनिया के लिए)।

टेट्रिमिनो शिफ्ट

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

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

89AE: LDA $0040
89B0: STA $00AE ; originalX = tetriminoX;

89B2: LDA $00B6 ; if (pressing down) {
89B4: AND #$04 ; return;
89B6: BNE $8A09 ; }

89B8: LDA $00B5 ; if (just pressed left/right) {
89BA: AND #$03 ; goto resetAutorepeatX;
89BC: BNE $89D3 ; }

89BE: LDA $00B6 ; if (not pressing left/right) {
89C0: AND #$03 ; return;
89C2: BEQ $8A09 ; }

89C4: INC $0046 ; autorepeatX++;
89C6: LDA $0046 ; if (autorepeatX < 16) {
89C8: CMP #$10 ; return;
89CA: BMI $8A09 ; }

89CC: LDA #$0A
89CE: STA $0046 ; autorepeatX = 10;
89D0: JMP $89D7 ; goto buttonHeldDown;

resetAutorepeatX:

89D3: LDA #$00
89D5: STA $0046 ; autorepeatX = 0;

buttonHeldDown:

89D7: LDA $00B6 ; if (not pressing right) {
89D9: AND #$01 ; goto notPressingRight;
89DB: BEQ $89EC ; }

89DD: INC $0040 ; tetriminoX++;
89DF: JSR $948B ; if (new position not valid) {
89E2: BNE $8A01 ; goto restoreX;
; }

89E4: LDA #$03
89E6: STA $06F1 ; play shift sound effect;
89E9: JMP $8A09 ; return;

notPressingRight:

89EC: LDA $00B6 ; if (not pressing left) {
89EE: AND #$02 ; return;
89F0: BEQ $8A09 ; }

89F2: DEC $0040 ; tetriminoX--;
89F4: JSR $948B ; if (new position not valid) {
89F7: BNE $8A01 ; goto restoreX;
; }

89F9: LDA #$03
89FB: STA $06F1 ; play shift sound effect;
89FE: JMP $8A09 ; return;

restoreX:

8A01: LDA $00AE
8A03: STA $0040 ; tetriminoX = originalX;

8A05: LDA #$10
8A07: STA $0046 ; autorepeatX = 16;

8A09: RTS ; return;

x

टेट्रिमिनो फेंकना

टेट्रिमिनो के स्वचालित वंश की गति स्तर संख्या का एक कार्य है। स्पीड को एन्कोड किया गया है क्योंकि स्थित तालिका में वंश के लिए प्रदान किए गए फ़्रेमों की संख्या $898E। चूंकि एनईएस 60.0988 फ्रेम / एस पर चल रहा है, आप अवरोही और गति के बीच की अवधि की गणना कर सकते हैं।

स्तर	अवरोही तख्ते	अवधि (एस / वंश)	गति (कोशिकाएं)
0	48	0.799	1.25
1	43	0.715	1.40
2	38	0.632	1.58
3	33	0.549	1.82
4	28	0.466	2.15
5	23	0.383	2.61
6	18	.300	3.34
7	13	0.216	4.62
8	8	0.133	7.51
9	6	.100	10.02
10-12	5	0.083	12.02
13-15	4	0.067	15.05
16-18	3	.050	20.03
19-28	2	0.033	30.05
29+	1	0.017	60.10

तालिका में कुल 30 प्रविष्टियाँ हैं। 29 के स्तर के बाद, वंश के लिए फ़्रेम का मूल्य हमेशा 1 होता है। वंश के लिए फ़्रेम का

एक पूर्णांक संख्या गति का वर्णन करने का एक बहुत विस्तृत तरीका नहीं है। जैसा कि नीचे ग्राफ में दिखाया गया है, गति प्रत्येक स्तर के साथ तेजी से बढ़ती है। वास्तव में, स्तर 29, स्तर 28 से दोगुना तेज़ है।

1 फ्रेम / डिसेंट के साथ, खिलाड़ी के पास स्थिति का पता लगाने के लिए 1/3 से अधिक नहीं है, जिसके बाद वह चलना शुरू कर देगा। इस मूल गति पर, DAS खेल के मैदान के किनारों तक पहुंचने की अनुमति नहीं देता है जब तक कि यह जगह पर लॉक नहीं हो जाता है, जो कि ज्यादातर लोगों के लिए खेल का एक त्वरित अंत है। हालांकि, कुछ खिलाड़ी, विशेष रूप से थोर अकरलंड , क्रॉस बटन ( D-pad) के त्वरित कंपन के साथ डीएएस को हराने में कामयाब रहे । ऊपर दिखाए गए शिफ्ट कोड में, यह देखा जा सकता है कि जब क्षैतिज दिशा बटन फ्रेम के माध्यम से जारी किया जाता है, तो टेट्रीमिनो को 29 और उसके बाद के संस्करण को आधे आवृत्ति के साथ स्थानांतरित करना संभव है। यह एक सैद्धांतिक अधिकतम है, लेकिन 3.75 टैप / एस से ऊपर अंगूठे के किसी भी कंपन से 16 फ्रेम की मूल देरी को हराया जा सकता है।

यदि स्वचालित और खिलाड़ी-नियंत्रित वंश ("डाउन" दबाकर) एक फ्रेम में मेल खाता और घटित होता है, तो प्रभाव नहीं जुड़ता है। किसी भी या इन दोनों घटनाओं के कारण इस फ्रेम में एक सेल बिल्कुल नीचे चली जाती है।

ट्रिगर नियंत्रण तर्क पर स्थित है $8914। अवरोही फ्रेम टेबल लेबल के नीचे है । जैसा कि ऊपर उल्लेख किया गया है, 29 और ऊपर के स्तर पर, गति लगातार 1 शटर / फ्रेम के बराबर होती है। (पता ) पहुंचते ही वंश शुरू हो जाता है ( )। इस कोड के टुकड़े के बाहर एक पते पर वेतन वृद्धि की जाती है । स्वचालित या नियंत्रित वंश के दौरान, इसे 0. पर रीसेट किया जाता है। चर ( ) पते पर मूल्य के साथ आरंभ किया जाता है

8914: LDA $004E ; if (autorepeatY > 0) {
8916: BPL $8922 ; goto autorepeating;
; } else if (autorepeatY == 0) {
; goto playing;
; }

; game just started
; initial Tetrimino hanging at spawn point

8918: LDA $00B5 ; if (not just pressed down) {
891A: AND #$04 ; goto incrementAutorepeatY;
891C: BEQ $8989 ; }

; player just pressed down ending startup delay

891E: LDA #$00
8920: STA $004E ; autorepeatY = 0;
8922: BNE $8939

playing:

8924: LDA $00B6 ; if (left or right pressed) {
8926: AND #$03 ; goto lookupDropSpeed;
8928: BNE $8973 ; }

; left/right not pressed

892A: LDA $00B5
892C: AND #$0F ; if (not just pressed only down) {
892E: CMP #$04 ; goto lookupDropSpeed;
8930: BNE $8973 ; }

; player exclusively just presssed down

8932: LDA #$01
8934: STA $004E ; autorepeatY = 1;

8936: JMP $8973 ; goto lookupDropSpeed;

autorepeating:

8939: LDA $00B6
893B: AND #$0F ; if (down pressed and not left/right) {
893D: CMP #$04 ; goto downPressed;
893F: BEQ $894A ; }

; down released

8941: LDA #$00
8943: STA $004E ; autorepeatY = 0
8945: STA $004F ; holdDownPoints = 0
8947: JMP $8973 ; goto lookupDropSpeed;

downPressed:

894A: INC $004E ; autorepeatY++;
894C: LDA $004E
894E: CMP #$03 ; if (autorepeatY < 3) {
8950: BCC $8973 ; goto lookupDropSpeed;
; }

8952: LDA #$01
8954: STA $004E ; autorepeatY = 1;

8956: INC $004F ; holdDownPoints++;

drop:

8958: LDA #$00
895A: STA $0045 ; fallTimer = 0;

895C: LDA $0041
895E: STA $00AE ; originalY = tetriminoY;

8960: INC $0041 ; tetriminoY++;
8962: JSR $948B ; if (new position valid) {
8965: BEQ $8972 ; return;
; }

; the piece is locked

8967: LDA $00AE
8969: STA $0041 ; tetriminoY = originalY;

896B: LDA #$02
896D: STA $0048 ; playState = UPDATE_PLAYFIELD;
896F: JSR $9CAF ; updatePlayfield();

8972: RTS ; return;

lookupDropSpeed:

8973: LDA #$01 ; tempSpeed = 1;

8975: LDX $0044 ; if (level >= 29) {
8977: CPX #$1D ; goto noTableLookup;
8979: BCS $897E ; }

897B: LDA $898E,X ; tempSpeed = framesPerDropTable[level];

noTableLookup:

897E: STA $00AF ; dropSpeed = tempSpeed;

8980: LDA $0045 ; if (fallTimer >= dropSpeed) {
8982: CMP $00AF ; goto drop;
8984: BPL $8958 ; }

8986: JMP $8972 ; return;

incrementAutorepeatY:

8989: INC $004E ; autorepeatY++;
898B: JMP $8972 ; return;

lookupDropSpeed

fallTimer$0045dropSpeed$00AFfallTimer$8892

autorepeatY$004E$0A$8739), जिसकी व्याख्या ed96 के रूप में की जाती है। बहुत शुरुआत में एक स्थिति एक प्रारंभिक देरी का कारण बनती है। बहुत पहले टेट्रिमिनो निर्माण के बिंदु पर हवा में निलंबित रहता है जब तक कि autorepeatYयह 0 तक बढ़ जाता है, जिसमें 1.6 सेकंड लगते हैं। हालाँकि, जब आप इस चरण में नीचे दबाते हैं, तो इसे autorepeatYतुरंत असाइन किया जाता है 0. यह दिलचस्प है कि आप इसे रद्द किए बिना प्रारंभिक देरी के इस चरण में आंकड़ा को स्थानांतरित और घुमा सकते हैं। धरने के दौरान

वेतन वृद्धि की autorepeatYजाती है। जब यह 3 तक पहुंचता है, तो एक मानव-नियंत्रित वंश ("नरम" वंश) होता है और इसे autorepeatYसौंपा जाता है। 1. इसलिए, प्रारंभिक नरम वंश में 3 फ्रेम की आवश्यकता होती है, लेकिन फिर इसे प्रत्येक फ्रेम में दोहराया जाता है।

इसके अलावा, यह autorepeatY0 से 1 तक बढ़ जाता है जब खेल यह पहचानता है कि खिलाड़ी ने अभी डाउन (पर) क्लिक किया है$00B5), लेकिन नीचे पकड़े पहचान नहीं करता है। यह महत्वपूर्ण है क्योंकि यह autorepeatYटेट्रीमिनो (पते पर $98E8) बनाते समय 0 पर रीसेट हो जाता है , जो एक महत्वपूर्ण विशेषता बनाता है: यदि खिलाड़ी खुद आंकड़ा कम करता है और इसे अवरुद्ध किया जाता है, और वह अगला आंकड़ा बनाते समय "डाउन" दबाता रहता है, जो अक्सर उच्च स्तर पर होता है, तब यह नए आंकड़े के नरम वंश के लिए नेतृत्व नहीं करेगा। ऐसा होने के लिए, खिलाड़ी को "डाउन" जारी करना होगा और फिर बटन को फिर से दबाना होगा।

संभावित रूप से कोमल वंश अंक बढ़ा सकते हैं। holdDownPoints( $004F) प्रत्येक वंश के साथ बढ़ता है, लेकिन जब जारी किया जाता है, तो "डाउन" को 0. पर रीसेट किया जाता है। इसलिए, अंक स्कोर करने के लिए, टेट्रीमिनो को नरम वंश के साथ लॉक में कम करना आवश्यक है। अल्पकालिक नरम वंश, जो आंकड़े के रास्ते में हो सकता है, अंक को प्रभावित नहीं करता है। खाते में अद्यतन किया जाता है$9BFE, लेकिन holdDownPointsपते पर, इसके तुरंत बाद 0 पर रीसेट कर दिया जाता है $9C2F।

चेक, जो खिलाड़ी को आंकड़े की क्षैतिज पारी के साथ नरम वंश प्रदर्शन करने से रोकता है, अंक के सेट को जटिल करता है। इसका मतलब है कि जगह को लॉक करने से पहले आखिरी चाल "नीचे" होनी चाहिए।

जब ढलान जा रहा है, tetriminoY( $0041) में बनाई जाए originalY( $00AE)। यदि वेतन वृद्धि द्वारा बनाई गई नई स्थिति tetriminoYगलत हो जाती है (यानी, आंकड़ा या तो खेल के मैदान के फर्श के माध्यम से धक्का देता है, या पहले से ही झूठ बोलने वाले वर्गों पर लगाया जाता है), तो टेट्रीमिनो पिछली स्थिति में रहता है। इस मामले में, इसे पुनर्स्थापित किया जाता हैtetriminoYऔर आंकड़ा अवरुद्ध माना जाता है। इसका मतलब यह है कि लॉक करने से पहले देरी (तिमित्रिनो की अपेक्षा अधिकतम फ़्रेम, लॉकिंग से पहले हवा में पकड़ना) वंश में देरी के बराबर है।

निन्टेंडो टेट्रिस में कठोर वंश (तुरन्त गिरने) का समर्थन नहीं किया जाता है।

स्लाइडिंग और स्क्रॉलिंग

निन्टेंडो टेट्रिस मैनुअल पुस्तिका में एक सचित्र स्लिप उदाहरण है:

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

दूसरी ओर, स्क्रॉलिंग आपको उन स्थानों में आंकड़े दिखाने की अनुमति देता है जो किसी अन्य तरीके से अप्राप्य हैं (नीचे देखें)।

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

948B: LDA $0041
948D: ASL
948E: STA $00A8
9490: ASL
9491: ASL
9492: CLC
9493: ADC $00A8
9495: ADC $0040
9497: STA $00A8

9499: LDA $0042
949B: ASL
949C: ASL
949D: STA $00A9
949F: ASL
94A0: CLC
94A1: ADC $00A9
94A3: TAX ; index = 12 * orientationID;
94A4: LDY #$00

94A6: LDA #$04
94A8: STA $00AA ; for(i = 0; i < 4; i++) {

94AA: LDA $8A9C,X ; squareY = orientationTable[index];
94AD: CLC
94AE: ADC $0041 ; cellY = squareY + tetriminoY;
94B0: ADC #$02 ; if (cellY < -2 || cellY >= 20) {
94B2: CMP #$16 ; return false;
94B4: BCS $94E9 ; }

94B6: LDA $8A9C,X
94B9: ASL
94BA: STA $00AB
94BC: ASL
94BD: ASL
94BE: CLC
94BF: ADC $00AB
94C1: CLC
94C2: ADC $00A8
94C4: STA $00AD

94C6: INX
94C7: INX ; index += 2;

94C8: LDA $8A9C,X ; squareX = orientationTable[index];
94CB: CLC
94CC: ADC $00AD
94CE: TAY ; cellX = squareX + tetriminoX;
94CF: LDA ($B8),Y ; if (playfield[10 * cellY + cellX] != EMPTY_TILE) {
94D1: CMP #$EF ; return false;
94D3: BCC $94E9 ; }

94D5: LDA $8A9C,X
94D8: CLC
94D9: ADC $0040 ; if (cellX < 0 || cellX >= 10) {
94DB: CMP #$0A ; return false;
94DD: BCS $94E9 ; }

94DF: INX ; index++;
94E0: DEC $00AA
94E2: BNE $94AA ; }

94E4: LDA #$00
94E6: STA $00A8
94E8: RTS ; return true;

94E9: LDA #$FF
94EB: STA $00A8
94ED: RTS

index = (orientationID << 3) + (orientationID << 2); // index = 8 * orientationID + 4 * orientationID;

(cellY << 3) + (cellY << 1) // 8 * cellY + 2 * cellY

खेल मैदान पर संबंधित सेल स्थान प्राप्त करने के लिए चक्र के प्रत्येक पुनरावृत्ति अभिविन्यास तालिका से वर्गों में से एक के सापेक्ष निर्देशांक द्वारा टेट्रीमिनो स्थिति को स्थानांतरित करता है। वह तब जाँचती है कि सेल का निर्देशन खेल के मैदान की सीमाओं के भीतर है, और सेल स्वयं खाली है।

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

94AA: LDA $8A9C,X ; squareY = orientationTable[index];
94AD: CLC
94AE: ADC $0041 ; cellY = squareY + tetriminoY;
94B0: ADC #$02 ; if (cellY + 2 >= 22) {
94B2: CMP #$16 ; return false;
94B4: BCS $94E9 ; }

cellY$FE(दशमलव संकेतन में 254)।

खेल के मैदान का सूचकांक cellY10 से गुणा किया जाता है और cellX। हालांकि, जब , cellY1 ( $FF= 255) या $FE=2 ( = 254), तो उत्पाद (10 ( $F6= 246) और (20 ( $EC= 236) देता है। अंतराल में होने के कारण, यह cellX9 से अधिक नहीं हो सकता है, जो 246 + 9 = 255 का अधिकतम सूचकांक देता है, और यह खेल मैदान के अंत की तुलना में बहुत अधिक है। हालांकि, खेल इनिशियलाइज़ करता है $0400- $04FFएक वैल्यू $EF(एक खाली टाइल) के साथ, खाली स्थान का एक और 56 अतिरिक्त बाइट्स बनाते हुए।

अजीब है कि अंतराल की जाँच करेंcellXखेल मैदान के सेल की जांच के बाद प्रदर्शन किया गया। लेकिन यह किसी भी क्रम में सही ढंग से काम करता है। इसके अलावा, अंतराल की जांच करना समग्र स्थिति से बचा जाता है, जैसा कि नीचे टिप्पणी में संकेत दिया गया है। नीचे दिए गए स्क्रॉलिंग उदाहरण इस कोड की जांच करने के तरीके के कारण संभव हैं।

94D5: LDA $8A9C,X
94D8: CLC
94D9: ADC $0040 ; if (cellX >= 10) {
94DB: CMP #$0A ; return false;
94DD: BCS $94E9 ; }

जैसा कि नीचे दिखाया गया है, आप स्क्रॉलिंग के साथ स्लाइडिंग भी कर सकते हैं।

ऐनी निंटेंडो टेट्रिस की चलती क्षमताओं का पूरा फायदा उठाता है, जिसमें स्लाइडिंग और स्क्रॉलिंग शामिल है।

स्तर 30 और उससे ऊपर

30 के स्तर तक पहुंचने के बाद, ऐसा लगता है कि स्तर शून्य पर रीसेट हो गया है।

लेकिन स्तर 31 दर्शाता है कि कुछ और हो रहा है:

प्रदर्शित स्तर मान पते पर तालिका में स्थित हैं $96B8।

96B8: 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

नीचे दिखाया गया है, पैटर्न तालिका इसलिए आदेश दिया जाता है कि के साथ टाइल्स $00पर $0Fग्लिफ़ के लिए प्रतीक हैं 0पर F। इसका मतलब यह है कि जब एक दशमलव या हेक्साडेसिमल अंक प्रदर्शित करते हैं, तो अंक के मूल्य को पैटर्न तालिका के सूचकांक के रूप में उपयोग किया जाता है। हमारे मामले में, स्तर मान द्विआधारी-कोडित दशमलव (बीसीडी) के रूप में संग्रहीत किए जाते हैं; अनुक्रम में प्रत्येक बाइट के प्रत्येक कुतरना एक टाइल मूल्य है।

दुर्भाग्य से, ऐसा लगता है कि गेम डिजाइनरों ने यह मान लिया कि कोई भी 29 के स्तर से नहीं गुज़रेगा, और इसलिए उसने तालिका में केवल 30 प्रविष्टियाँ सम्मिलित करने का निर्णय लिया। तालिका के बाद अजीब प्रदर्शित मूल्य अलग-अलग बाइट्स हैं। केवल एक बाइट (पते पर $0044) का उपयोग स्तर संख्या को इंगित करने के लिए किया जाता है , यही वजह है कि खेल धीरे-धीरे नीचे दिखाए गए 256 मूल्यों के आसपास चक्र करता है।

`00`	`0`	`1`	`2`	`3`	`4`	`5`	`6`	`7`	`8`	`9`	`A`	`B`	`C`	`D`	`E`	`F`
`0`	`00`	`01`	`02`	`03`	`04`	`05`	`06`	`07`	`08`	`09`	`10`	`11`	`12`	`13`	`14`	`15`
`1`	`16`	`17`	`18`	`19`	`20`	`21`	`22`	`23`	`24`	`25`	`26`	`27`	`28`	`29`	`00`	`0A`
`2`	`14`	`1E`	`28`	`32`	`3C`	`46`	`50`	`5A`	`64`	`6E`	`78`	`82`	`8C`	`96`	`A0`	`AA`
`3`	`B4`	`BE`	`C6`	`20`	`E6`	`20`	`06`	`21`	`26`	`21`	`46`	`21`	`66`	`21`	`86`	`21`
`4`	`A6`	`21`	`C6`	`21`	`E6`	`21`	`06`	`22`	`26`	`22`	`46`	`22`	`66`	`22`	`86`	`22`
`5`	`A6`	`22`	`C6`	`22`	`E6`	`22`	`06`	`23`	`26`	`23`	`85`	`A8`	`29`	`F0`	`4A`	`4A`
`6`	`4A`	`4A`	`8D`	`07`	`20`	`A5`	`A8`	`29`	`0F`	`8D`	`07`	`20`	`60`	`A6`	`49`	`E0`
`7`	`15`	`10`	`53`	`BD`	`D6`	`96`	`A8`	`8A`	`0A`	`AA`	`E8`	`BD`	`EA`	`96`	`8D`	`06`
`8`	`20`	`CA`	`A5`	`BE`	`C9`	`01`	`F0`	`1E`	`A5`	`B9`	`C9`	`05`	`F0`	`0C`	`BD`	`EA`
`9`	`96`	`38`	`E9`	`02`	`8D`	`06`	`20`	`4C`	`67`	`97`	`BD`	`EA`	`96`	`18`	`69`	`0C`
`A`	`8D`	`06`	`20`	`4C`	`67`	`97`	`BD`	`EA`	`96`	`18`	`69`	`06`	`8D`	`06`	`20`	`A2`
`B`	`0A`	`B1`	`B8`	`8D`	`07`	`20`	`C8`	`CA`	`D0`	`F7`	`E6`	`49`	`A5`	`49`	`C9`	`14`
`C`	`30`	`04`	`A9`	`20`	`85`	`49`	`60`	`A5`	`B1`	`29`	`03`	`D0`	`78`	`A9`	`00`	`85`
`D`	`AA`	`A6`	`AA`	`B5`	`4A`	`F0`	`5C`	`0A`	`A8`	`B9`	`EA`	`96`	`85`	`A8`	`A5`	`BE`
`E`	`C9`	`01`	`D0`	`0A`	`A5`	`A8`	`18`	`69`	`06`	`85`	`A8`	`4C`	`BD`	`97`	`A5`	`B9`
`F`	`C9`	`04`	`D0`	`0A`	`A5`	`A8`	`38`	`E9`	`02`	`85`	`A8`	`4C`	`BD`	`97`	`A5`	`A8`

पहले 20 क्रमिक मूल्य वास्तव में एक और तालिका है जो 20 पंक्तियों में से प्रत्येक के लिए खेल के मैदान पर ऑफसेट स्टोर करती है। चूंकि खेल का मैदान शुरू होता है और प्रत्येक पंक्ति में 10 सेल होते हैं, इसलिए एक मनमाना सेल का पता है: यह देखते हुए कि प्रोसेसर सीधे गुणन का समर्थन नहीं करता है, यह लुकअप तालिका उत्पाद प्राप्त करने का एक बहुत तेज़ तरीका प्रदान करती है। इसी तालिका में अगले 40 बाइट्स हैं। इसमें Nametable 0 (पृष्ठभूमि टाइल्स के मूल्यों वाले VRAM मेमोरी क्षेत्र) के लिए थोड़ा एंडियन प्रारूप में 20 पते शामिल हैं। वे खेल के मैदान की ऑफसेट लाइनों की ओर संकेत करते हैं । शेष बाइट जिसमें से प्रदर्शित स्तर मानों की रचना होती है, निर्देश हैं।

96D6: 00 ; 0
96D7: 0A ; 10
96D8: 14 ; 20
96D9: 1E ; 30
96DA: 28 ; 40
96DB: 32 ; 50
96DC: 3C ; 60
96DD: 46 ; 70
96DE: 50 ; 80
96DF: 5A ; 90
96E0: 64 ; 100
96E1: 6E ; 110
96E2: 78 ; 120
96E3: 82 ; 130
96E4: 8C ; 140
96E5: 96 ; 150
96E6: A0 ; 160
96E7: AA ; 170
96E8: B4 ; 180
96E9: BE ; 190

$0400

$0400 + 10 * y + x

$0400 + [$96D6 + y] + x

$06

पंक्तियाँ और आँकड़े

पूर्ण पंक्तियों और टेट्रिमिनो आँकड़ों की संख्या निम्नलिखित पतों पर 2 बाइट्स पर कब्जा कर लेती है।

पता	संख्या
`0050` - `0051`	पंक्तियाँ
`03F0` - `03F1`	टी
`03F2` - `03F3`	जम्मू
`03F4` - `03F5`	जेड
`03F6` - `03F7`	हे
`03F8` - `03F9`	एस
`03FA` - `03FB`	एल
`03FC` - `03FD`	मैं

वास्तव में, इन मूल्यों को 16-बिट पैक किए गए छोटे एंडियन बीसीडी के रूप में संग्रहीत किया जाता है। उदाहरण के लिए, पंक्तियों की संख्या नीचे दिखाई गई है, जो कि 123 है। बाइट्स को दाईं से बाईं ओर गिना जाता है ताकि दशमलव अंक क्रम में जाएं।

हालांकि, गेम डिजाइनरों ने यह मान लिया कि कोई भी मूल्य 999 से अधिक नहीं होगा। इसलिए, प्रदर्शन तर्क सही ढंग से पहले बाइट को एक पैक बीसीडी के रूप में संसाधित करता है, जहां प्रत्येक निबल को टाइल मूल्य के रूप में उपयोग किया जाता है। लेकिन पूरे दूसरे बाइट को वास्तव में शीर्ष दशमलव अंक के रूप में उपयोग किया जाता है। जब निचले अंक से 99जाते हैं 00, तो दूसरी बाइट की सामान्य वृद्धि होती है। नतीजतन, सभी 256 टाइलों के माध्यम से दूसरा बाइट चक्र। इसका एक उदाहरण नीचे दिखाया गया है।

पंक्ति को साफ़ करने के बाद, पंक्तियों की संख्या बढ़ाने के लिए निम्न कोड निष्पादित किया जाता है। चेक मध्य और निचले अंकों के लिए किए जाते हैं ताकि वे 0 और 9 के बीच रहें। लेकिन ऊपरी अंक को असीम रूप से बढ़ाया जा सकता है। यदि पंक्तियों की संख्या में वृद्धि के बाद निचला अंक 0 है, तो इसका मतलब है कि खिलाड़ी ने सिर्फ 10 लाइनों का एक सेट पूरा किया है और आपको स्तर संख्या बढ़ाने की आवश्यकता है। जैसा कि आप नीचे दिए गए कोड से देख सकते हैं, स्तर वृद्धि से पहले एक अतिरिक्त जांच की जाती है। दूसरा चेक चयनित प्रवेश स्तर से संबंधित है। प्रारंभिक स्तर की परवाह किए बिना, एक निश्चित स्तर पर जाने के लिए , खिलाड़ी को स्पष्ट होना चाहिए

9BA8: INC $0050 ; increment middle-lowest digit pair
9BAA: LDA $0050
9BAC: AND #$0F
9BAE: CMP #$0A ; if (lowest digit > 9) {
9BB0: BMI $9BC7
9BB2: LDA $0050
9BB4: CLC
9BB5: ADC #$06 ; set lowest digit to 0, increment middle digit
9BB7: STA $0050
9BB9: AND #$F0
9BBB: CMP #$A0 ; if (middle digit > 9) {
9BBD: BCC $9BC7
9BBF: LDA $0050
9BC1: AND #$0F
9BC3: STA $0050 ; set middle digit to 0
9BC5: INC $0051 ; increment highest digit
; }
; }

9BC7: LDA $0050
9BC9: AND #$0F
9BCB: BNE $9BFB ; if (lowest digit == 0) {
9BCD: JMP $9BD0

9BD0: LDA $0051
9BD2: STA $00A9
9BD4: LDA $0050
9BD6: STA $00A8 ; copy digits from $0050-$0051 to $00A8-$00A9

9BD8: LSR $00A9
9BDA: ROR $00A8
9BDC: LSR $00A9
9BDE: ROR $00A8
9BE0: LSR $00A9
9BE2: ROR $00A8 ; treat $00A8-$00A9 as a 16-bit packed BCD value
9BE4: LSR $00A9 ; and right-shift it 4 times
9BE6: ROR $00A8 ; this leaves the highest and middle digits in $00A8

9BE8: LDA $0044
9BEA: CMP $00A8 ; if (level < [$00A8]) {
9BEC: BPL $9BFB

9BEE: INC $0044 ; increment level
; }
; }

X10Xलाइनों। उदाहरण के लिए, यदि कोई खिलाड़ी 5 स्तर पर शुरू होता है, तो वह उस पर तब तक बना रहेगा जब तक वह 60 लाइनों को साफ नहीं करता है, और फिर 6 स्तर पर चला जाता है। उसके बाद, प्रत्येक अतिरिक्त 10 लाइनें स्तर संख्या में वृद्धि का कारण बनेंगी।

इस जांच को करने के लिए, भरे हुए पंक्तियों के मूल्य को - से $0050- $0051तक कॉपी किया जाता है । फिर कॉपी को दाईं ओर 4 बार स्थानांतरित किया जाता है, जो एक पैक किए गए बीसीडी के लिए 10. द्वारा विभाजित के समान है। सबसे छोटे दशमलव अंक को छोड़ दिया जाता है, और उच्चतम और मध्य अंकों को एक स्थान पर स्थानांतरित किया जाता है, जिसके परिणामस्वरूप nibbles होते हैं ।$00A8$00A9$00A8

हालांकि, पते पर, $9BEAस्तर संख्या सीधे बीसीडी के पैक किए गए मूल्य की तुलना में है $00A8। BCD मान को दशमलव में बदलने के लिए तालिका में कोई खोज नहीं है, और यह एक स्पष्ट त्रुटि है। उदाहरण के लिए, ऊपर की तस्वीर में, स्तर संख्या की तुलना $12(दशमलव में 18) के साथ की जानी चाहिए , न कि 12. इसलिए, यदि कोई खिलाड़ी 17 स्तर से शुरू करने का फैसला करता है, तो स्तर वास्तव में 120 पंक्तियों में जाएगा, क्योंकि 18 से अधिक है 17.

तालिका प्रत्येक प्रारंभिक स्तर पर संक्रमण के लिए अपेक्षित पंक्तियों की संख्या दर्शाती है। इसकी तुलना एक बग के कारण वास्तव में होती है।

0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19
10	20	30	40	50	60	70	80	90	100	110	120	130	140	150	160	170	180	190	200
10	20	30	40	50	60	70	80	90	100	100	100	100	100	100	100	110	120	130	140

अपेक्षित राशि प्रारंभिक स्तर 0–9 के लिए सही है। वास्तव में, प्रवेश स्तर 9 के लिए संयोग यादृच्छिक है; 10-15 पंक्तियों के साथ 10-15 भी अगले स्तर पर जाता है, क्योंकि $10- यह दशमलव रूप में 16 है। अपेक्षित और वास्तविक के बीच सबसे बड़ा अंतर 60 पंक्तियों का है।

मुझे संदेह है कि बग विकास के बाद के चरणों में डिजाइन में बदलाव के कारण है। मेनू स्क्रीन पर देखें, खिलाड़ी को प्रवेश स्तर चुनने की अनुमति देता है।

9. ऊपर के स्तरों से शुरू करने के बारे में कोई व्याख्या नहीं है। लेकिन निन्टेंडो टेट्रिस बुकलेट में इस रहस्य का खुलासा हुआ है:

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

वास्तव में, प्रारंभिक श्रृंखला की जाँच में अंतराल के लिए मूल्यों के उत्पादन से संबंधित एक दूसरी त्रुटि है। नीचे दिए गए कोड में टिप्पणियाँ हैं जो बेहतर बताती हैं कि निम्न स्तर पर क्या होता है। परिणाम के संकेत को घटाकर और जाँच कर तुलना की जाती है। लेकिन एक एकल-बाइट हस्ताक्षरित संख्या 127128 से 127 तक सीमित है। यदि अंतर ,128 से कम है, तो संख्या को ले जाया जाता है और परिणाम एक सकारात्मक संख्या बन जाता है। इस सिद्धांत को कोड पर टिप्पणियों में समझाया गया है। इस अंतराल में अंतर की जाँच करते समय, यह ध्यान में रखा जाना चाहिए कि स्तर संख्या, जब 255 से अधिक के मानों में वृद्धि हो रही है, तो हस्तांतरण को 0 पर ले जाता है, और

9BE8: LDA $0044
9BEA: CMP $00A8 ; if (level - [$00A8] < 0) {
9BEC: BPL $9BFB

9BEE: INC $0044 ; increment level
; }

9BE8: LDA $0044 ; difference = level - [$00A8];
9BEA: CMP $00A8 ; if (difference < 0 && difference >= -128) {
9BEC: BPL $9BFB

9BEE: INC $0044 ; increment level
; }

$00A8संभावित रूप से इसमें कोई भी मूल्य हो सकता है, क्योंकि इसका ऊपरी कुतरना से लिया जाता है $0051, जिसमें से वृद्धि असीम रूप से हो सकती है।

ये प्रभाव ओवरलैप करते हैं, ऐसी अवधि बनाते हैं जिसमें स्तर संख्या गलती से अपरिवर्तित रहती है। पीरियड्स 2,900 पंक्तियों के नियमित अंतराल पर होते हैं, 2,190 पंक्तियों से शुरू होते हैं, और 800 पंक्तियों तक रहते हैं। उदाहरण के लिए, 2190 ( L90) से 2990 ( T90) तक, स्तर नीचे $DB( 96) के बराबर रहता है , जैसा कि नीचे दिखाया गया है।

अगली अवधि 5090 से 5890 तक होती है, स्तर लगातार $AD( 06) के बराबर होता है । इसके अलावा, इन अवधि के दौरान, रंग पैलेट भी नहीं बदलता है।

टेट्रिमिनो रंग पेज

प्रत्येक स्तर पर, टेट्रीमिनो टाइल्स को 4 अद्वितीय रंग दिए गए हैं। रंग स्थित टेबल से लिए गए हैं $984C। उसके रिकॉर्ड का हर 10 स्तरों पर पुन: उपयोग किया जाता है। बाएं से दाएं: नीचे दी गई छवि के काले, सफेद, नीले और लाल क्षेत्रों के अनुरूप तालिका के कॉलम।

984C: 0F 30 21 12 ; level 0
9850: 0F 30 29 1A ; level 1
9854: 0F 30 24 14 ; level 2
9858: 0F 30 2A 12 ; level 3
985C: 0F 30 2B 15 ; level 4
9860: 0F 30 22 2B ; level 5
9864: 0F 30 00 16 ; level 6
9868: 0F 30 05 13 ; level 7
986C: 0F 30 16 12 ; level 8
9870: 0F 30 27 16 ; level 9

मान NES रंग पैलेट के अनुरूप हैं।

प्रत्येक प्रविष्टि के पहले 2 रंग हमेशा काले और सफेद होते हैं। हालांकि, पहला रंग वास्तव में अनदेखा किया गया है; मूल्य की परवाह किए बिना, यह एक पारदर्शी रंग माना जाता है, जिसके माध्यम से एक ठोस काले रंग की पृष्ठभूमि होती है।

रंग तालिका तक पहुंच दिनचर्या में की जाती है $9808। रंग तालिका सूचकांक 10. के शेष द्वारा विभाजित स्तर संख्या पर आधारित है। चक्र वीआरएएम में पैलेट तालिकाओं के प्रवेश की प्रतिलिपि बनाता है। शेष के साथ विभाजन 10 के निरंतर घटाव द्वारा अनुकरण किया जाता है जब तक कि परिणाम 10 से कम न हो। टिप्पणियों के साथ उप-रेखा की शुरुआत नीचे दिखाई गई है।

9808: LDA $0064
980A: CMP #$0A
980C: BMI $9814
980E: SEC
980F: SBC #$0A
9811: JMP $980A ; index = levelNumber % 10;

9814: ASL
9815: ASL
9816: TAX ; index *= 4;

9817: LDA #$00
9819: STA $00A8 ; for(i = 0; i < 32; i += 16) {

981B: LDA #$3F
981D: STA $2006
9820: LDA #$08
9822: CLC
9823: ADC $00A8
9825: STA $2006 ; palette = $3F00 + i + 8;

9828: LDA $984C,X
982B: STA $2007 ; palette[0] = colorTable[index + 0];

982E: LDA $984D,X
9831: STA $2007 ; palette[1] = colorTable[index + 1];

9834: LDA $984E,X
9837: STA $2007 ; palette[2] = colorTable[index + 2];

983A: LDA $984F,X
983D: STA $2007 ; palette[3] = colorTable[index + 3];

9840: LDA $00A8
9842: CLC
9843: ADC #$10
9845: STA $00A8
9847: CMP #$20
9849: BNE $981B ; }

984B: RTS ; return;

9808: LDA $0064 ; index = levelNumber;
980A: CMP #$0A ; while(index >= 10) {
980C: BMI $9814
980E: SEC
980F: SBC #$0A ; index -= 10;
9811: JMP $980A ; }

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

9808: LDA $0064 ; index = levelNumber;
; difference = index - 10;
980A: CMP #$0A ; while(difference >= 0 && difference <= 127) {
980C: BMI $9814
980E: SEC ; index -= 10;
980F: SBC #$0A ; difference = index - 10;
9811: JMP $980A ; }

9808: LDA $0064 ; index = levelNumber;
980A: CMP #$0A ; while(index >= 10 && index <= 137) {
980C: BMI $9814
980E: SEC
980F: SBC #$0A ; index -= 10;
9811: JMP $980A ; }

नीचे सभी 256 स्तरों के रंग हैं। रंगीन तालिका के चक्रीय उपयोग पर जोर देने के लिए टाइलों को 10 स्तंभों में व्यवस्थित किया जाता है, जिसका स्तर 138 पर उल्लंघन किया जाता है। हेडर में पंक्तियों और स्तंभों को दशमलव में दर्शाया गया है।

255 के बाद, स्तर संख्या 0. पर लौट आती है।

इसके अलावा, जैसा कि पिछले अनुभाग में बताया गया है, कुछ स्तर 800 पंक्तियों को हटाए जाने तक नहीं बदलते हैं। इन लंबे स्तरों के दौरान, रंग अपरिवर्तित रहते हैं।

खेल मोड

पते पर संग्रहीत गेम मोड $00C0यह निर्धारित करता है कि वर्तमान में उपयोगकर्ता को विभिन्न स्क्रीन और मेनू में से कौन सा प्रदर्शित किया गया है।

मूल्य	विवरण
`00`	कानूनी जानकारी स्क्रीन
`01`	स्पलैश स्क्रीन
`02`	खेल प्रकार मेनू
`03`	स्तरों और ऊंचाइयों का मेनू
`04`	गेम / हाईस्कोर / समाप्त / रोकें
`05`	डेमो

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

8161: LDA $00C0
8163: JSR $AC82 ; switch(gameMode) {
8166: 00 82 ; case 0: goto 8200; //
8168: 4F 82 ; case 1: goto 824F; //
816A: D1 82 ; case 2: goto 82D1; //
816C: D7 83 ; case 3: goto 83D7; //
816E: 5D 81 ; case 4: goto 815D; // / / /
8170: 5D 81 ; case 5: goto 815D; //
; }

$0000$0001

AC82: ASL
AC83: TAY
AC84: INY

AC85: PLA
AC86: STA $0000
AC88: PLA ; pop return address off of stack
AC89: STA $0001 ; and store it at $0000-$0001

AC8B: LDA ($00),Y
AC8D: TAX
AC8E: INY
AC8F: LDA ($00),Y
AC91: STA $0001
AC93: STX $0000
AC95: JMP ($0000) ; goto Ath 16-bit address
; in table at [$0000-$0001]

कोड इस स्विच दिनचर्या का उपयोग कर सकता है जब तक कि सूचकांक 0 के करीब हैं और संभावित मामलों के बीच कोई स्थान या कुछ नहीं हैं।

कानूनी जानकारी स्क्रीन

खेल एक स्क्रीन के साथ शुरू होता है जो कानूनी नोटिस दिखाता है।

स्क्रीन के निचले भाग में, Aleksey Pazhitnov को पहले टेट्रिस के आविष्कारक, डिजाइनर और प्रोग्रामर के रूप में उल्लेख किया गया है। 1984 में, डोरोडनिट्स कम्प्यूटिंग सेंटर (मॉस्को में रूसी अकादमी ऑफ साइंसेज के एक प्रमुख शोध संस्थान) में एक कंप्यूटर डेवलपर के रूप में काम करते हुए , उन्होंने इलेक्ट्रॉनिक्स -60 (सोवियत क्लोन डीईसी एलएसआई -11 ) पर गेम का एक प्रोटोटाइप विकसित किया । एक हरे रंग के मोनोक्रोम पाठ मोड के लिए एक प्रोटोटाइप विकसित किया गया था जिसमें वर्ग वर्ग कोष्ठक के जोड़े द्वारा इंगित किया गया है []। 16 वर्षीय स्कूली छात्र वादिम गेरासिमोव और कंप्यूटर इंजीनियर दिमित्री पावलोवस्की की मदद से खेल के आविष्कार के कुछ दिनों बाद, प्रोटोटाइप को एमएस डॉस और टर्बो पास्कल के साथ एक आईबीएम पीसी में रखा गया था।। दो वर्षों के दौरान, उन्होंने एक साथ गेम में सुधार किया, टेट्रीमिनो रंग, सांख्यिकी, और अधिक महत्वपूर्ण बात, एक समय और ग्राफिक्स कोड जैसी सुविधाओं को जोड़ते हुए, जिसने गेम को कई पीसी मॉडल और क्लोन पर काम करने की अनुमति दी।

दुर्भाग्य से, उस समय सोवियत संघ की ख़ासियत के कारण, खेल को मुद्रीकृत करने के उनके प्रयास असफल रहे और अंत में उन्होंने मुफ्त में अपने दोस्तों के साथ पीसी संस्करण साझा करने का फैसला किया। उस क्षण से, "टेट्रिस" पूरे देश में और उससे आगे, डिस्क से डिस्क में कॉपी किया जाने लगा। लेकिन चूंकि खेल एक सरकारी एजेंसी के कर्मचारियों द्वारा विकसित किया गया था, राज्य के पास इसका स्वामित्व था, और 1987 में इलेक्ट्रॉनिक प्रौद्योगिकियों में अंतर्राष्ट्रीय व्यापार के लिए जिम्मेदार संगठन ने खेल का लाइसेंस ( इलेक्ट्रॉनगोरटेख्निका (एलएलओजी)) संभाला।)। कानूनी जानकारी स्क्रीन पर संक्षिप्त नाम V / O, वर्जन ओरिजिनल के लिए छोटा हो सकता है।

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

दिलचस्प बात यह है कि इस संस्करण में, स्कूल के लड़के वादिम गेरासिमोव को मूल डिजाइनर और प्रोग्रामर कहा जाता है।

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

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

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

इसके बाद एक जटिल कानूनी लड़ाई हुई। निनटेंडो और टेंगेन दोनों ने मांग की कि विरोधी पक्ष खेल के अपने संस्करण का उत्पादन और बिक्री बंद कर दे। नतीजतन, निन्टेंडो जीत गया, और सैकड़ों हजारों टेंगेन टेट्रिस कारतूस नष्ट हो गए। अदालत के फैसले ने कई अन्य कंपनियों जैसे मिररसॉफ्ट को कंसोल संस्करण बनाने से प्रतिबंधित कर दिया।

पाजिटनोव ने कभी भी ELORG या सोवियत राज्य से कोई कटौती प्राप्त नहीं की। हालांकि, 1991 में वह बुलेट-प्रूफ सॉफ्टवेयर के मालिक के समर्थन से यूएसए और 1996 में चले गएहेन्का रोजर्स ने द टेट्रिस कंपनी की सह-स्थापना की , जिसने उन्हें मोबाइल उपकरणों और आधुनिक कंसोल के लिए संस्करणों से लाभ उठाने की अनुमति दी।

यह कानूनी जानकारी स्क्रीन को देखने के लिए दिलचस्प है, एक खिड़की के रूप में खेल की मूल उत्पत्ति और बौद्धिक संपदा अधिकारों के लिए आने वाली लड़ाइयों का एक विचार है, क्योंकि अधिकांश खिलाड़ियों के लिए यह स्क्रीन सिर्फ एक कष्टप्रद बाधा है, जिसके गायब होने का हमेशा के लिए इंतजार करना पड़ता है। देरी को दो काउंटरों द्वारा सेट किया जाता है, क्रमिक रूप से 255 से 0. तक गिनती की जाती है। पहले चरण को छोड़ नहीं दिया जा सकता है, और दूसरा प्रारंभ बटन दबाकर छोड़ दिया जाता है। इसलिए, कानूनी जानकारी स्क्रीन को कम से कम 4.25 सेकंड और 8.5 सेकंड से अधिक नहीं दिखाया गया है। हालांकि, मुझे लगता है कि अधिकांश खिलाड़ी पहले अंतराल के दौरान स्टार्टिंग को रोकना छोड़ देते हैं, और इस वजह से वे पूरा होने का इंतजार कर रहे हैं।

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

8005: PHA
8006: TXA
8007: PHA
8008: TYA
8009: PHA ; save A, X, Y

800A: LDA #$00
800C: STA $00B3
800E: JSR $804B ; render();

8011: DEC $00C3 ; legalScreenCounter1--;

8013: LDA $00C3
8015: CMP #$FF ; if (legalScreenCounter1 < 0) {
8017: BNE $801B ; legalScreenCounter1 = 0;
8019: INC $00C3 ; }

801B: JSR $AB5E ; initializeOAM();

801E: LDA $00B1
8020: CLC
8021: ADC #$01
8023: STA $00B1
8025: LDA #$00
8027: ADC $00B2
8029: STA $00B2 ; frameCounter++;

802B: LDX #$17
802D: LDY #$02
802F: JSR $AB47 ; randomValue = generateNextPseudorandomNumber(randomValue);

8032: LDA #$00
8034: STA $00FD
8036: STA $2005 ; scrollX = 0;
8039: STA $00FC
803B: STA $2005 ; scrollY = 0;

803E: LDA #$01
8040: STA $0033 ; verticalBlankingInterval = true;

8042: JSR $9D51 ; pollControllerButtons();

8045: PLA
8046: TAY
8047: PLA
8048: TAX
8049: PLA ; restore A, X, Y

804A: RTI ; resume interrupted task

render()initializeOAM()फ़्रेम जनरेशन उपकरण द्वारा आवश्यक चरण निष्पादित करता है। हैंडलर फ्रेम काउंटर को बढ़ाकर काम करना जारी रखता है $00B1- पते पर संग्रहीत 16-बिट थोड़ा एंडियन मूल्य - $00B2जो इसे नियंत्रित समय के लिए विभिन्न स्थानों में उपयोग करता है। उसके बाद, निम्नलिखित छद्म यादृच्छिक संख्या उत्पन्न होती है; जैसा कि ऊपर उल्लेख किया गया है, यह प्रति फ्रेम कम से कम एक बार मोड की परवाह किए बिना होता है। $8040ऊर्ध्वाधर रिक्त अंतराल अंतराल को पता पर सेट किया गया है , जिसका अर्थ है कि हैंडलर को अभी निष्पादित किया गया है। अंत में, नियंत्रक बटन प्रदूषित हैं; इस दिनचर्या का व्यवहार डेमो सेक्शन में नीचे वर्णित है।

ध्वज का verticalBlankingIntervalउपयोग ऊपर चर्चा की गई दिनचर्या द्वारा किया जाता है। यह तब तक जारी रहता है जब तक कि बाधा हैंडलर का निष्पादन शुरू नहीं हो जाता।

AA2F: JSR $E000 ; updateAudio();

AA32: LDA #$00
AA34: STA $0033 ; verticalBlankingInterval = false;

AA36: NOP

AA37: LDA $0033
AA39: BEQ $AA37 ; while(!verticalBlankingInterval) { }

AA3B: LDA #$FF
AA3D: LDX #$02
AA3F: LDY #$02
AA41: JSR $AC6A ; fill memory page 2 with all $FF's

AA44: RTS ; return;

इस अवरुद्ध दिनचर्या का उपयोग कानूनी जानकारी स्क्रीन के समय के दो चरणों द्वारा किया जाता है, जिन्हें एक के बाद एक निष्पादित किया जाता है। Lua AI स्क्रिप्ट दोनों काउंटरों को 0 पर सेट करके इस देरी को बाईपास करती है।

8236: LDA #$FF
8238: JSR $A459

...

A459: STA $00C3 ; legalScreenCounter1 = 255;

A45B: JSR $AA2F ; do {
A45E: LDA $00C3 ; waitForVerticalBlankingInterval();
A460: BNE $A45B ; } while(legalScreenCounter1 > 0);

A462: RTS ; return;

823B: LDA #$FF
823D: STA $00A8 ; legalScreenCounter2 = 255;

; do {

823F: LDA $00F5 ; if (just pressed Start) {
8241: CMP #$10 ; break;
8243: BEQ $824C ; }

8245: JSR $AA2F ; waitForVerticalBlankingInterval();

8248: DEC $00A8 ; legalScreenCounter2--;
824A: BNE $823F ; } while(legalScreenCounter2 > 0);

824C: INC $00C0 ; gameMode = TITLE_SCREEN;

डेमो

डेमो प्री-रिकॉर्डेड गेमप्ले के बारे में 80 सेकंड दिखाता है। यह केवल वीडियो फ़ाइल को प्रदर्शित नहीं करता है, बल्कि खेल में उसी इंजन का उपयोग करता है। प्लेबैक के दौरान, दो तालिकाओं का उपयोग किया जाता है। पते पर स्थित सबसे पहले, $DF00टेट्रीमिनो बनाने के निम्नलिखित अनुक्रम शामिल हैं:

TJTSZJTSZJSZLZJTTSITO JSZLZLIOLZLIOJTSITOJ

एक आंकड़ा बनाते समय, यह या तो यादृच्छिक रूप से चुना जाता है, या तालिका से पढ़ा जाता है, मोड पर निर्भर करता है। पते पर स्विचिंग होती है $98EB। टेट्रिमिनो प्रकार प्रत्येक बाइट के बिट्स 6, 5 और 4 से निकाला जाता है। समय-समय पर, यह ऑपरेशन हमें एक मूल्य देता है - गलत प्रकार। हालांकि, आकार बनाने तालिका ( ) tetrimino आईडी अभिविन्यास में एक प्रकार रूपांतरण के लिए इस्तेमाल किया वास्तव में दोनों आपस में जुड़े तालिकाओं के बीच स्थित है: अर्थ

98EB: LDA $00C0
98ED: CMP #$05
98EF: BNE $9903 ; if (gameMode == DEMO) {

98F1: LDX $00D3
98F3: INC $00D3
98F5: LDA $DF00,X ; value = demoTetriminoTypeTable[++demoIndex];

98F8: LSR
98F9: LSR
98FA: LSR
98FB: LSR
98FC: AND #$07
98FE: TAX ; tetriminoType = bits 6,5,4 of value;

98FF: LDA $994E,X
9902: RTS ; return spawnTable[tetriminoType];
; } else {
; pickRandomTetrimino();
; }

$07$994E

993B: 00 00 00 00 ; T
993F: 01 01 01 01 ; J
9943: 02 02 ; Z
9945: 03 ; O
9946: 04 04 ; S
9948: 05 05 05 05 ; L
994C: 06 06 ; I

994E: 02 ; Td
994F: 07 ; Jd
9950: 08 ; Zh
9951: 0A ; O
9952: 0B ; Sh
9953: 0E ; Ld
9954: 12 ; Ih

9956: 02 02 02 02 ; Td
995A: 07 07 07 07 ; Jd
995E: 08 08 ; Zh
9960: 0A ; O
9961: 0B 0B ; Sh
9963: 0E 0E 0E 0E ; Ld
9967: 12 12 ; Ih

$07यह तालिका के अंत से परे, अगले में पढ़ने के लिए मजबूर करता है, जो देता है Td( $02)।

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

डेमो मोड के आरंभीकरण के दौरान, टेबल इंडेक्स ( $00D3) पते पर रीसेट हो जाता है $872B।

डेमो की दूसरी तालिका में बाइट्स के जोड़े में एन्कोडेड गेमपैड बटन का रिकॉर्ड है। पहले बाइट के बिट्स बटन के अनुरूप हैं।

`7`	`6`	`5`	`4`	`3`	`2`	`1`	`0`
एक	बी	चुनना	प्रारंभ	ऊपर	नीचे	बाईं ओर	दाईं ओर

दूसरा बाइट फ्रेम की संख्या को संग्रहीत करता है जिसके दौरान बटन का एक संयोजन दबाया जाता है।

तालिका पते लेती है $DD00- $DEFFऔर 256 जोड़े होते हैं। पते पर सबरूटीन द्वारा इसका उपयोग किया जाता है $9D5B। चूंकि डेमो बटन तालिका 512 बाइट्स लंबी है, इसलिए इसे एक्सेस करने के लिए दो-बाइट इंडेक्स की आवश्यकता होती है। सूचकांक को कम एंडियन के रूप में संग्रहीत किया जाता है - । यह तालिका के पते के मूल्य के साथ आरंभीकृत होता है , और इसकी वृद्धि निम्नलिखित कोड द्वारा की जाती है। प्रोग्रामर ने कोड में खिलाड़ी के इनपुट प्रसंस्करण को छोड़ दिया, जो हमें विकास प्रक्रिया को देखने और डेमो को दूसरे रिकॉर्ड के साथ बदलने की अनुमति देता है। जब एक मान असाइन किया जाता है तो डेमो रिकॉर्डिंग मोड सक्रिय होता है।

9D5B: LDA $00D0 ; if (recording mode) {
9D5D: CMP #$FF ; goto recording;
9D5F: BEQ $9DB0 ; }

9D61: JSR $AB9D ; pollController();
9D64: LDA $00F5 ; if (start button pressed) {
9D66: CMP #$10 ; goto startButtonPressed;
9D68: BEQ $9DA3 ; }

9D6A: LDA $00CF ; if (repeats == 0) {
9D6C: BEQ $9D73 ; goto finishedMove;
; } else {
9D6E: DEC $00CF ; repeats--;
9D70: JMP $9D9A ; goto moveInProgress;
; }

finishedMove:

9D73: LDX #$00
9D75: LDA ($D1,X)
9D77: STA $00A8 ; buttons = demoButtonsTable[index];

9D79: JSR $9DE8 ; index++;

9D7C: LDA $00CE
9D7E: EOR $00A8
9D80: AND $00A8
9D82: STA $00F5 ; setNewlyPressedButtons(difference between heldButtons and buttons);

9D84: LDA $00A8
9D86: STA $00CE ; heldButtons = buttons;

9D88: LDX #$00
9D8A: LDA ($D1,X)
9D8C: STA $00CF ; repeats = demoButtonsTable[index];

9D8E: JSR $9DE8 ; index++;

9D91: LDA $00D2 ; if (reached end of demo table) {
9D93: CMP #$DF ; return;
9D95: BEQ $9DA2 ; }

9D97: JMP $9D9E ; goto holdButtons;

moveInProgress:

9D9A: LDA #$00
9D9C: STA $00F5 ; clearNewlyPressedButtons();

holdButtons:

9D9E: LDA $00CE
9DA0: STA $00F7 ; setHeldButtons(heldButtons);

9DA2: RTS ; return;

startButtonPressed:

9DA3: LDA #$DD
9DA5: STA $00D2 ; reset index;

9DA7: LDA #$00
9DA9: STA $00B2 ; counter = 0;

9DAB: LDA #$01
9DAD: STA $00C0 ; gameMode = TITLE_SCREEN;

9DAF: RTS ; return;

$00D1$00D2$872D

9DE8: LDA $00D1
9DEA: CLC ; increment [$00D1]
9DEB: ADC #$01 ; possibly causing wrap around to 0
9DED: STA $00D1 ; which produces a carry

9DEF: LDA #$00
9DF1: ADC $00D2
9DF3: STA $00D2 ; add carry to [$00D2]

9DF5: RTS ; return

$00D0$FF। इस मामले में, निम्न कोड लॉन्च किया गया है, जिसका उद्देश्य डेमो के लिए बटन की मेज पर लिखना है। हालाँकि, तालिका PRG-ROM में संग्रहीत है। इसे लिखने का प्रयास सहेजे गए डेटा को प्रभावित नहीं करेगा। इसके बजाय, प्रत्येक लेखन ऑपरेशन एक बैंक स्विच को ट्रिगर करता है, जिसके परिणामस्वरूप नीचे दिखाए गए गड़बड़ प्रभाव होते हैं।

recording:

9DB0: JSR $AB9D ; pollController();

9DB3: LDA $00C0 ; if (gameMode != DEMO) {
9DB5: CMP #$05 ; return;
9DB7: BNE $9DE7 ; }

9DB9: LDA $00D0 ; if (not recording mode) {
9DBB: CMP #$FF ; return;
9DBD: BNE $9DE7 ; }

9DBF: LDA $00F7 ; if (getHeldButtons() == heldButtons) {
9DC1: CMP $00CE ; goto buttonsNotChanged;
9DC3: BEQ $9DE4 ; }

9DC5: LDX #$00
9DC7: LDA $00CE
9DC9: STA ($D1,X) ; demoButtonsTable[index] = heldButtons;

9DCB: JSR $9DE8 ; index++;

9DCE: LDA $00CF
9DD0: STA ($D1,X) ; demoButtonsTable[index] = repeats;

9DD2: JSR $9DE8 ; index++;

9DD5: LDA $00D2 ; if (reached end of demo table) {
9DD7: CMP #$DF ; return;
9DD9: BEQ $9DE7 ; }

9DDB: LDA $00F7
9DDD: STA $00CE ; heldButtons = getHeldButtons();

9DDF: LDA #$00
9DE1: STA $00CF ; repeats = 0;

9DE3: RTS ; return;

buttonsNotChanged:

9DE4: INC $00CF ; repeats++;

9DE6: RTS
9DE7: RTS ; return;

इससे पता चलता है कि डेवलपर्स प्रोग्राम को आंशिक रूप से या पूरी तरह से रैम में चला सकते हैं।

इस बाधा को प्राप्त करने के लिए, मैंने स्रोत कोड के साथ ज़िपlua/RecordDemo.lua में स्थित एक बनाया । डेमो रिकॉर्डिंग मोड पर स्विच करने के बाद, यह Lua कंसोल में लिखने के संचालन को टेबल पर पुनर्निर्देशित करता है। इससे बाइट्स को कॉपी करके ROM में चिपकाया जा सकता है।

अपना स्वयं का डेमो रिकॉर्ड करने के लिए, FCEUX चलाएं और निन्टेंडो टेट्रिस रॉम फाइल (फाइल | ओपन रॉम ...) डाउनलोड करें। फिर Lua Script विंडो खोलें (फ़ाइल | Lua | New Lua Script Window ...), फ़ाइल में ब्राउज़ करें या पथ दर्ज करें। डेमो रिकॉर्डिंग मोड शुरू करने के लिए रन बटन दबाएं, और फिर फोकस पर स्विच करने के लिए FCEUX विंडो पर क्लिक करें। जब तक बटन तालिका भर नहीं जाती तब तक आप आकृतियों को नियंत्रित कर सकते हैं। उसके बाद, गेम स्वचालित रूप से स्क्रीन सेवर में वापस आ जाएगा। स्क्रिप्ट को रोकने के लिए Lua Script विंडो में स्टॉप पर क्लिक करें। रिकॉर्ड किया गया डेटा आउटपुट कंसोल में दिखाई देगा, जैसा कि नीचे दिए गए चित्र में दिखाया गया है।

सभी सामग्री का चयन करें और क्लिपबोर्ड पर कॉपी करें (Ctrl + C)। फिर हेक्स एडिटर (डिबग | हेक्स एडिटर ...) चलाएं। हेक्स संपादक मेनू से, दृश्य का चयन करें | ROM फ़ाइल और फिर फ़ाइल | गोटो का पता। गोटो संवाद बॉक्स में, 5D10 (ROM फ़ाइल में डेमो बटन की तालिका का पता) दर्ज करें और ओके पर क्लिक करें। फिर क्लिपबोर्ड की सामग्री (Ctrl + V) पेस्ट करें।

अंत में, FCEUX मेनू में, NES का चयन करें रीसेट करें। यदि आप इन सभी चरणों को दोहराने में कामयाब रहे, तो डेमो को आपके स्वयं के संस्करण द्वारा प्रतिस्थापित किया जाना चाहिए।

यदि आप परिवर्तनों को सहेजना चाहते हैं, तो फ़ाइल का चयन करें सहेजें के रूप में रोम ... और संशोधित ROM फ़ाइल का नाम दर्ज करें, और तब सहेजें पर क्लिक करें।

इसी तरह से, आप बनाए गए टेट्रिमिनोस के अनुक्रम को समायोजित कर सकते हैं।

मौत की स्क्रीन

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

मृत्यु की एक सच्ची स्क्रीन लगभग 1550 पंक्तियों पर दिखाई देती है जो पीछे हट जाती है। यह अलग-अलग तरीकों से खुद को प्रकट करता है। कभी-कभी खेल पुनरारंभ होता है। अन्य मामलों में, स्क्रीन बस काली हो जाती है। आमतौर पर एक गेम एक पंक्ति को हटाने के तुरंत बाद ("जमा देता है"), जैसा कि नीचे दिखाया गया है। इस तरह के प्रभाव अक्सर यादृच्छिक ग्राफिक कलाकृतियों से पहले होते हैं।

मौत स्क्रीन कोड में एक बग का परिणाम है जो पंक्तियों को हटाते समय अंक जोड़ता है। छह-चरित्र वाला खाता 24-बिट पैक वाले एंडियन बीसीडी के रूप में संग्रहीत किया जाता है और यहां स्थित है $0053- $0055। प्राप्त पंक्तियों और अंकों की संख्या के बीच रूपांतरण करने के लिए, एक तालिका का उपयोग किया जाता है; इसमें प्रत्येक प्रविष्टि 16-बिट पैक वाली बीसीडी लिटिल एंडियन वैल्यू है। पंक्तियों की कुल संख्या, और संभवतः स्तर को बढ़ाने के बाद, इस सूची में मान को स्तर संख्या प्लस एक से गुणा किया जाता है, और परिणाम अंकों में जोड़ा जाता है। यह निन्टेंडो टेट्रिस मैनुअल पुस्तिका से तालिका में स्पष्ट रूप से प्रदर्शित किया गया है:

9CA5: 00 00 ; 0: 0
9CA7: 40 00 ; 1: 40
9CA9: 00 01 ; 2: 100
9CAB: 00 03 ; 3: 300
9CAD: 00 12 ; 4: 1200

जैसा कि नीचे दिखाया गया है, गुणा एक चक्र द्वारा सिम्युलेटेड है जो स्कोर में अंक जोड़ता है। आकार को लॉक करने के बाद इसे निष्पादित किया जाता है, भले ही कोई पंक्तियां साफ न हों। दुर्भाग्य से, रिको 2A03 में 6502 बाइनरी दशमलव मोड नहीं है; वह चक्र के शरीर को बहुत सरल कर सकता था। इसके बजाय, बाइनरी मोड का उपयोग करके चरणों में प्रदर्शन किया जाता है। जोड़ के बाद 9 से अधिक किसी भी अंक को अनिवार्य रूप से 10 घटाकर और बाईं ओर अंकों को बढ़ाकर प्राप्त किया जाता है। उदाहरण के लिए, इसे रूपांतरित किया गया है । लेकिन ऐसी योजना पूरी तरह से संरक्षित नहीं है। लो : एक चेक परिणाम को बदलने में असमर्थ है

9C31: LDA $0044
9C33: STA $00A8
9C35: INC $00A8 ; for(i = 0; i <= level; i++) {

9C37: LDA $0056
9C39: ASL
9C3A: TAX
9C3B: LDA $9CA5,X ; points[0] = pointsTable[2 * completedLines];

9C3E: CLC
9C3F: ADC $0053
9C41: STA $0053 ; score[0] += points[0];

9C43: CMP #$A0
9C45: BCC $9C4E ; if (upper digit of score[0] > 9) {

9C47: CLC
9C48: ADC #$60
9C4A: STA $0053 ; upper digit of score[0] -= 10;
9C4C: INC $0054 ; score[1]++;
; }

9C4E: INX
9C4F: LDA $9CA5,X ; points[1] = pointsTable[2 * completedLines + 1];

9C52: CLC
9C53: ADC $0054
9C55: STA $0054 ; score[1] += points[1];

9C57: AND #$0F
9C59: CMP #$0A
9C5B: BCC $9C64 ; if (lower digit of score[1] > 9) {

9C5D: LDA $0054
9C5F: CLC ; lower digit of score[1] -= 10;
9C60: ADC #$06 ; increment upper digit of score[1];
9C62: STA $0054 ; }

9C64: LDA $0054
9C66: AND #$F0
9C68: CMP #$A0
9C6A: BCC $9C75 ; if (upper digit of score[1] > 9) {

9C6C: LDA $0054
9C6E: CLC
9C6F: ADC #$60
9C71: STA $0054 ; upper digit of score[1] -= 10;
9C73: INC $0055 ; score[2]++;
; }

9C75: LDA $0055
9C77: AND #$0F
9C79: CMP #$0A
9C7B: BCC $9C84 ; if (lower digit of score[2] > 9) {

9C7D: LDA $0055
9C7F: CLC ; lower digit of score[2] -= 10;
9C80: ADC #$06 ; increment upper digit of score[2];
9C82: STA $0055 ; }

9C84: LDA $0055
9C86: AND #$F0
9C88: CMP #$A0
9C8A: BCC $9C94 ; if (upper digit of score[2] > 9) {

9C8C: LDA #$99
9C8E: STA $0053
9C90: STA $0054
9C92: STA $0055 ; max out score to 999999;
; }

9C94: DEC $00A8
9C96: BNE $9C37 ; }

$07 + $07 = $0E$14$09 + $09 = $12$18। इसकी भरपाई करने के लिए, स्कोरकार्ड में प्रविष्टियों में दशमलव अंकों में से एक भी नहीं। 6. इसके अलावा, इसका उपयोग करने में सक्षम होने के लिए, सभी रिकॉर्डों का अंतिम अंक हमेशा 0. होता है।

इस लंबे और जटिल चक्र को पूरा करने में समय लगता है। उच्च स्तरों पर, बड़ी संख्या में पुनरावृत्तियां खेल के समय को प्रभावित करती हैं, क्योंकि प्रत्येक फ्रेम को उत्पन्न करने में 1/60 सेकंड से अधिक समय लगता है। परिणामस्वरूप यह सब "मौत की स्क्रीन" की विभिन्न अभिव्यक्तियों की ओर जाता है।

लुआ एआई स्क्रिप्ट एक लूप में पुनरावृत्तियों की संख्या को 30 तक सीमित करता है - अधिकतम मूल्य जो डिजाइनर डिजाइनरों द्वारा डिज़ाइन किए जा सकते हैं, जो मौत की स्क्रीन को समाप्त करता है।

अंत

निन्टेंडो टेट्रिस बुकलेट में, ए-टाइप गेम का वर्णन इस प्रकार है:

खेल उन खिलाड़ियों को पुरस्कृत करता है जिन्होंने अंत के पांच एनिमेशनों में से एक में पर्याप्त संख्या में अंक अर्जित किए हैं। समाप्त होने का विकल्प पूरी तरह से छह अंकों के स्कोर के दो सबसे बाएं अंकों पर आधारित है। जैसा कि नीचे दिखाया गया है, अंत में से एक पाने के लिए, खिलाड़ी को कम से कम 30,000 अंक प्राप्त करने चाहिए। यह ध्यान देने योग्य है कि - पते का एक दर्पण है - । खाता पते पर डुप्लिकेट है - । पहला परीक्षण पास करने के बाद, अंतिम एनीमेशन का चयन निम्न स्विच स्टेटमेंट द्वारा किया जाता है।

9A4D: LDA $0075
9A4F: CMP #$03
9A51: BCC $9A5E ; if (score[2] >= $03) {

9A53: LDA #$80
9A55: JSR $A459
9A58: JSR $9E3A
9A5B: JMP $9A64 ; select ending;
; }

$0060$007F$0040$005F$0073$0075

A96E: LDA #$00
A970: STA $00C4
A972: LDA $0075 ; if (score[2] < $05) {
A974: CMP #$05 ; ending = 0;
A976: BCC $A9A5 ; }

A978: LDA #$01
A97A: STA $00C4
A97C: LDA $0075 ; else if (score[2] < $07) {
A97E: CMP #$07 ; ending = 1;
A980: BCC $A9A5 ; }

A982: LDA #$02
A984: STA $00C4
A986: LDA $0075 ; else if (score[2] < $10) {
A988: CMP #$10 ; ending = 2;
A98A: BCC $A9A5 ; }

A98C: LDA #$03
A98E: STA $00C4
A990: LDA $0075 ; else if (score[2] < $12) {
A992: CMP #$12 ; ending = 3;
A994: BCC $A9A5 ; }

A996: LDA #$04 ; else {
A998: STA $00C4 ; ending = 4;
; }

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

`30000–49999`	`50000–69999`	`70000–99999`
`100000–119999`	`120000+`

बी-टाइप गेम मोड में, एक और परीक्षण लागू किया गया है, जो निनटेंडो टेट्रिस बुकलेट में निम्नानुसार वर्णित है:

यदि खिलाड़ी 25 पंक्तियों को सफलतापूर्वक साफ़ करता है, तो प्रारंभिक स्तर के आधार पर, खेल समाप्ति को दर्शाता है। स्तर ०- consist के लिए अंत में सेंट बेसिल कैथेड्रल के पीछे रहस्यमय तरीके से गुजरने वाले जानवरों और वस्तुओं को शामिल किया गया है जो फ्रेम में उड़ते हैं या चल रहे हैं। ए-टाइप मोड का सबसे अच्छा अंत से यूएफओ 3 के अंत में प्रकट होता है। अंत 4 में, विलुप्त होने वाले फ्लाइंग पेंटरोस दिखाई देते हैं, और अंत में 7 में पौराणिक फ्लाइंग ड्रेगन दिखाए जाते हैं। 2 और 6 के अंत में, पंखहीन पक्षियों को दिखाया गया है: पेंगुइन और शुतुरमुर्ग दौड़ते हुए। 5 के अंत में, आकाश GOOD airships (Goodyear airships के साथ भ्रमित नहीं होना) से भरा है। और 8 के अंत में, स्क्रीन पर बहुत सारे "बुरानास" तैरते हैं, हालांकि वास्तव में केवल एक ही था।

शुरुआती ऊंचाई (प्लस 1) का उपयोग एक गुणक के रूप में किया जाता है, जो खिलाड़ी को बड़ी संख्या में जानवरों / वस्तुओं के साथ बढ़ाता है, जिससे जटिलता बढ़ जाती है।

बी-टाइप के सबसे अच्छे अंत में, निनटेंडो ब्रह्मांड के पात्रों से भरा एक महल दिखाया गया है: राजकुमारी पीच उसके हाथों को ताली बजाती है, किड इकारस वायलिन बजाता है, गधा काँग बड़े ड्रम पर डोलता है, मारियो और लुइगी नृत्य करते हैं, बॉउजर अकॉर्डियन बजाता है, सैमस सेलो बजाता है, लिंक - एक बांसुरी पर, जबकि सेंट बेसिल के कैथेड्रल के गुंबद हवा में उड़ते हैं। अंत में दिखाए गए इन तत्वों की मात्रा प्रारंभिक ऊंचाई पर निर्भर करती है। नीचे सभी 10 अंत की छवियां दी गई हैं।

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

एंडिंग्स में ०-,, तक ६ ऑब्जेक्ट्स फ्रेम में जा सकते हैं। वस्तुओं का y निर्देशांक एक तालिका में स्थित होता है $A7B7। वस्तुओं के बीच क्षैतिज दूरी पते पर एक तालिका में संग्रहीत की जाती है । पते पर एक संकेत के साथ मूल्यों का अनुक्रम वस्तुओं की गति और दिशा निर्धारित करता है। स्प्राइट सूचकांकों को संग्रहीत किया जाता है । वास्तव में, प्रत्येक वस्तु में आसन्न सूचकांकों के साथ दो स्प्राइट होते हैं। दूसरा इंडेक्स प्राप्त करने के लिए आपको 1. जोड़ना होगा। उदाहरण के लिए, एक ड्रैगन के होते हैं

A7B7: 98 A8 C0 A8 90 B0 ; 0
A7BD: B0 B8 A0 B8 A8 A0 ; 1
A7C3: C8 C8 C8 C8 C8 C8 ; 2
A7C9: 30 20 40 28 A0 80 ; 3
A7CF: A8 88 68 A8 48 78 ; 4
A7D5: 58 68 18 48 78 38 ; 5
A7DB: C8 C8 C8 C8 C8 C8 ; 6
A7E1: 90 58 70 A8 40 38 ; 7
A7E7: 68 88 78 18 48 A8 ; 8

$A77B

A77B: 3A 24 0A 4A 3A FF ; 0
A781: 22 44 12 32 4A FF ; 1
A787: AE 6E 8E 6E 1E 02 ; 2
A78D: 42 42 42 42 42 02 ; 3
A793: 22 0A 1A 04 0A FF ; 4
A799: EE DE FC FC F6 02 ; 5
A79F: 80 80 80 80 80 FF ; 6
A7A5: E8 E8 E8 E8 48 FF ; 7
A7AB: 80 AE 9E 90 80 02 ; 8

$A771

A771: 01 ; 0: 1
A772: 01 ; 1: 1
A773: FF ; 2: -1
A774: FC ; 3: -4
A775: 01 ; 4: 1
A776: FF ; 5: -1
A777: 02 ; 6: 2
A778: 02 ; 7: 2
A779: FE ; 8: -1

$A7F3

A7F3: 2C ; 0: dragonfly
A7F4: 2E ; 1: dove
A7F5: 54 ; 2: penguin
A7F6: 32 ; 3: UFO
A7F7: 34 ; 4: pterosaur
A7F8: 36 ; 5: blimp
A7F9: 4B ; 6: ostrich
A7FA: 38 ; 7: dragon
A7FB: 3A ; 8: Buran

$38और $39। इन स्प्राइट्स के लिए टाइल नीचे पैटर्न टेबल में निहित हैं।

हमने ऊपर पैटर्न की केंद्रीय तालिका की जांच की, इसका उपयोग टेट्रीमिनो और खेल के मैदान को प्रदर्शित करने के लिए किया जाता है। दिलचस्प है, इसमें पूरी वर्णमाला शामिल है, जबकि अन्य में अंतरिक्ष को बचाने के लिए इसका केवल एक हिस्सा है। लेकिन इससे भी अधिक दिलचस्प यह है कि बाईं ओर पैटर्न टेबल में विमान और हेलीकॉप्टर स्प्राइट हैं; वे अंत में या खेल के अन्य हिस्सों में दिखाई नहीं देते हैं। यह पता चला कि विमान और हेलीकाप्टर अनुक्रमित स्प्राइट है $30और $16और आप ऊपर दिखाए गए तालिका बदल सकते हैं, उन्हें कार्रवाई में देखने के लिए।

दुर्भाग्य से, हेलीकॉप्टर माउंट प्रदर्शित नहीं होते हैं, लेकिन मुख्य और पूंछ रोटर खूबसूरती से एनिमेटेड हैं।

2 खिलाड़ी बनाम

निन्टेंडो टेट्रिस में एक अपूर्ण दो-प्लेयर मोड है जिसे आप खिलाड़ियों की संख्या को बदलकर सक्षम कर सकते हैं ( $00BE) 2 से। जैसा कि नीचे दिखाया गया है, दो गेम फ़ील्ड एकल-प्लेयर मोड की पृष्ठभूमि पर दिखाई देते हैं।

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

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

एक अतिरिक्त फ़ील्ड पर स्थित है $0500। ए $0060- $007F, आमतौर पर दर्पण होने के नाते $0040- $005Fदूसरे खिलाड़ी के लिए उपयोग किया जाता है।

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

संगीत और ध्वनि प्रभाव

जब $06F5तालिका में सूचीबद्ध मूल्यों में से एक को असाइन किया जाता है, तो पृष्ठभूमि संगीत चालू होता है।

मूल्य	विवरण
`01`	अप्रयुक्त छप स्क्रीन संगीत
`02`	प्राप्त बी-प्रकार मोड लक्ष्य
`03`	संगीत-1
`04`	संगीत-2
`05`	संगीत -3
`06`	संगीत -1 रूपक
`07`	संगीत -2 रूपक
`08`	संगीत -3 रूपक
`09`	बधाई हो स्क्रीन
`0A`	अंत
`0B`	प्राप्त बी-प्रकार मोड लक्ष्य

आप यहां स्क्रीन सेवर से अप्रयुक्त संगीत सुन सकते हैं । खेल में ही, स्क्रीन सेवर स्क्रीन के दौरान कुछ भी नहीं लगता है।

म्यूजिक -1 " डांस ऑफ द ड्रेजे परी " का एक संस्करण है , त्चिकोवस्की द्वारा पस डे ड्यूक्स वाल्ट्ज "द नटक्रैकर" के तीसरे अधिनियम से बैलेरीना के लिए संगीत । अंतिम संगीत " बुल्फाइटर वर्सेज " का एक रूपांतर है , ओपेरा कारमेन जॉर्जेस बिज़ेट से एक अरिया । इन रचनाओं को हिरोकाज़ू तनाका के बाकी संगीत के संगीतकार द्वारा व्यवस्थित किया गया है ।

संगीत -2 पारंपरिक लोकगीत रूसी गीतों से प्रेरित था। संगीत -3 रहस्यमय, भविष्य और निविदा है; कुछ समय के लिए, यह अमेरिका के ग्राहक सहायता फोन रिंगटोन की निन्टेंडो था।

खिलाड़ी को घबराहट की स्थिति में गिरने में मदद करने के लिए जब ढेर की ऊंचाई खेल के मैदान की छत के पास पहुंचती है, पृष्ठभूमि संगीत का एक संस्करण तेज गति ( $06- $08) पर खेलना शुरू कर देता है ।

दिलचस्प बात यह है कि संगीत रचनाओं में कोई " चैपमैन " नहीं है, जो एक प्रसिद्ध विषय है जो गेम बॉय टेट्रिस में लगता है।

ध्वनि प्रभाव को लिख कर शुरू कर रहे हैं $06F0और $06F1निम्न तालिका के अनुसार।

पता	मूल्य	विवरण
`06F0`	`02`	खेल के अंत का पर्दा
`06F0`	`03`	अंत में रॉकेट
`06F1`	`01`	मेनू विकल्प चयन
`06F1`	`02`	मेनू स्क्रीन चयन
`06F1`	`03`	टेट्रिमिनो शिफ्ट
`06F1`	`04`	टेट्रिस प्राप्त किया
`06F1`	`05`	टेट्रिमिनो रोटेशन
`06F1`	`06`	नया स्तर
`06F1`	`07`	टेट्रिमिनो लॉक
`06F1`	`08`	चहचहाना
`06F1`	`09`	रो सफाई
`06F1`	`0A`	रो भरा

गेम स्टेट्स और रेंडरिंग मोड

गेमप्ले के दौरान, खेल की वर्तमान स्थिति पते पर एक पूर्णांक द्वारा दर्शायी जाती है $0048। अधिकांश समय इसका एक अर्थ होता है $01जो इंगित करता है कि खिलाड़ी सक्रिय टेट्रीमिनो को नियंत्रित करता है। हालांकि, जब टुकड़ा जगह पर बंद हो जाता है, तो खेल धीरे-धीरे राज्य से राज्य $02तक जाता है $08, जैसा कि तालिका में दिखाया गया है।

राज्य	विवरण
`00`	अप्रमाणित ओरिएंटेशन आईडी
`01`	प्लेयर सक्रिय टेट्रीमिनो को नियंत्रित करता है
`02`	खेल मैदान पर टेट्रिमिनो लॉक
`03`	भरी पंक्तियों की जाँच
`04`	प्रदर्शन पंक्ति सफाई एनीमेशन
`05`	पंक्तियों और आँकड़ों को अद्यतन करना
`06`	बी-टाइप मोड के लक्ष्य की जाँच करना
`07`	उपयोग नहीं किया गया
`08`	अगली Tetrimino बनाएँ
`09`	उपयोग नहीं किया गया
`0A`	खेल परदा अद्यतन
`0B`	गेमिंग राज्य वेतन वृद्धि

कोड की ब्रांचिंग, खेल स्थिति के आधार पर, निम्न पते पर होती है $81B2: स्विच स्थिति में , यह उस कोड पर कूद जाता है जो एक मान बताता है कि अभिविन्यास निर्दिष्ट नहीं है। हैंडलर को कभी नहीं बुलाया जाता है; हालाँकि, खेल राज्य कोड के अन्य भागों के लिए एक संकेत के रूप में कार्य करता है। राज्य खिलाड़ी को सक्रिय टेट्रिमिनो को स्थानांतरित करने, घुमाने और कम करने की अनुमति देता है: जैसा कि पिछले अनुभागों में बताया गया है, कोड को निष्पादित करने से पहले आंकड़े की शिफ्ट, रोटेशन और कम दिनचर्या, टेट्रीमिनो के नए पदों की जांच करें। गलत स्थिति में किसी आकृति को अवरुद्ध करने का एकमात्र तरीका इसे मौजूदा आकार के शीर्ष पर बनाना है। इस मामले में, खेल समाप्त होता है। जैसा कि नीचे दिखाया गया है, स्टेटस कोड इस चेक को करता है।

81B2: LDA $0048
81B4: JSR $AC82 ; switch(playState) {
81B7: 2F 9E ; case 00: goto 9E2F; // Unassign orientationID
81B9: CF 81 ; case 01: goto 81CF; // Player controls active Tetrimino
81BB: A2 99 ; case 02: goto 99A2; // Lock Tetrimino into playfield
81BD: 6B 9A ; case 03: goto 9A6B; // Check for completed rows
81BF: 39 9E ; case 04: goto 9E39; // Display line clearing animation
81C1: 58 9B ; case 05: goto 9B58; // Update lines and statistics
81C3: F2 A3 ; case 06: goto A3F2; // B-Type goal check; Unused frame for A-Type
81C5: 03 9B ; case 07: goto 9B03; // Unused frame; Execute unfinished 2 player mode logic
81C7: 8E 98 ; case 08: goto 988E; // Spawn next Tetrimino
81C9: 39 9E ; case 09: goto 9E39; // Unused
81CB: 11 9A ; case 0A: goto 9A11; // Update game over curtain
81CD: 37 9E ; case 0B: goto 9E37; // Increment play state
; }

$00orientationID$13

9E2F: LDA #$13
9E31: STA $0042 ; orientationID = UNASSIGNED;

9E33: RTS ; return;

$00

$01

81CF: JSR $89AE ; shift Tetrimino;
81D2: JSR $88AB ; rotate Tetrimino;
81D5: JSR $8914 ; drop Tetrimino;

81D8: RTS ; return;

$02। यदि लॉक की स्थिति सही है, तो यह खेल के मैदान से जुड़ी 4 कोशिकाओं को कब्जे में लेता है। अन्यथा, वह एक राज्य के लिए संक्रमण बनाता है - खेल के अंत का अशुभ पर्दा।

99A2: JSR $948B ; if (new position valid) {
99A5: BEQ $99B8 ; goto updatePlayfield;
; }

99A7: LDA #$02
99A9: STA $06F0 ; play curtain sound effect;

99AC: LDA #$0A
99AE: STA $0048 ; playState = UPDATE_GAME_OVER_CURTAIN;

99B0: LDA #$F0
99B2: STA $0058 ; curtainRow = -16;

99B4: JSR $E003 ; updateAudio();

99B7: RTS ; return;

$0A

पर्दे को खेल के मैदान के शीर्ष से नीचे खींचा जाता है, हर 4 फ्रेम में एक पंक्ति उतरती है। curtainRow( $0058) ,16 के मान से आरंभ होता है, अंतिम लॉक और एनीमेशन की शुरुआत के बीच 0.27 सेकंड की अतिरिक्त देरी पैदा करता है। नीचे दिखाए गए कोड $9A21की स्थिति में पते पर $0A, गुणन तालिका तक पहुंचा जाता है, जिसे गलती से स्तर संख्याओं के रूप में प्रदर्शित किया जाता है। यह स्केल curtainRowद्वारा किया जाता है। इसके अतिरिक्त, जैसा कि ऊपर दिखाया गया है, पते पर कोड $9A51समाप्त होने वाले एनीमेशन को शुरू करता है यदि खिलाड़ी का स्कोर 30,000 अंकों से कम नहीं है; अन्यथा, यह प्रारंभ पर क्लिक करने की अपेक्षा करता है। कोड खेल राज्य के लिए एक मान निर्दिष्ट करके पूरा करता है , लेकिन संबंधित हैंडलर को नहीं बुलाया जाता है क्योंकि खेल पूरा हो गया है।

9A11: LDA $0058 ; if (curtainRow == 20) {
9A13: CMP #$14 ; goto endGame;
9A15: BEQ $9A47 ; }

9A17: LDA $00B1 ; if (frameCounter not divisible by 4) {
9A19: AND #$03 ; return;
9A1B: BNE $9A46 ; }

9A1D: LDX $0058 ; if (curtainRow < 0) {
9A1F: BMI $9A3E ; goto incrementCurtainRow;
; }

9A21: LDA $96D6,X
9A24: TAY ; rowIndex = 10 * curtainRow;

9A25: LDA #$00
9A27: STA $00AA ; i = 0;

9A29: LDA #$13
9A2B: STA $0042 ; orientationID = NONE;

drawCurtainRow:

9A2D: LDA #$4F
9A2F: STA ($B8),Y ; playfield[rowIndex + i] = CURTAIN_TILE;
9A31: INY
9A32: INC $00AA ; i++;
9A34: LDA $00AA
9A36: CMP #$0A ; if (i != 10) {
9A38: BNE $9A2D ; goto drawCurtainRow;
; }

9A3A: LDA $0058
9A3C: STA $0049 ; vramRow = curtainRow;

incrementCurtainRow:

9A3E: INC $0058 ; curtainRow++;

9A40: LDA $0058 ; if (curtainRow != 20) {
9A42: CMP #$14 ; return;
9A44: BNE $9A46 ; }

9A46: RTS ; return;

endGame:

9A47: LDA $00BE
9A49: CMP #$02
9A4B: BEQ $9A64 ; if (numberOfPlayers == 1) {

9A4D: LDA $0075
9A4F: CMP #$03
9A51: BCC $9A5E ; if (score[2] >= $03) {

9A53: LDA #$80
9A55: JSR $A459
9A58: JSR $9E3A
9A5B: JMP $9A64 ; select ending;
; }

9A5E: LDA $00F5 ; if (not just pressed Start) {
9A60: CMP #$10 ; return;
9A62: BNE $9A6A ; }
; }

9A64: LDA #$00
9A66: STA $0048 ; playState = INITIALIZE_ORIENTATION_ID;
9A68: STA $00F5 ; clear newly pressed buttons;

9A6A: RTS ; return;

$00

खेल के मैदान की रेखाएं उन्हें प्रदर्शित करने के लिए वीआरएएम में आकस्मिक रूप से कॉपी की जाती हैं। प्रतिलिपि की जाने वाली वर्तमान पंक्ति का सूचकांक vramRow( $0049) में समाहित है । एक $9A3C vramRowमान पते पर दिया गया है curtainRow, जो अंततः इस पंक्ति को प्रस्तुत करते समय दिखाई देता है।

वीआरएएम के साथ छेड़छाड़ एक ऊर्ध्वाधर रिक्त अंतराल के दौरान होती है, जिसे "कानूनी जानकारी स्क्रीन" अनुभाग में वर्णित बाधा हैंडलर द्वारा मान्यता प्राप्त है। यह नीचे दिखाए गए सबरूटिन को कॉल करता है (जैसे कि बाधा हैंडलर की टिप्पणियों में render())। रेंडरिंग मोड गेम मोड के समान है। इसे पते पर संग्रहीत किया जाता है और इसमें निम्न मान हो सकते हैं:

804B: LDA $00BD
804D: JSR $AC82 ; switch(renderMode) {
8050: B1 82 ; case 0: goto 82B1; // Legal and title screens
8052: DA 85 ; case 1: goto 85DA; // Menu screens
8054: 44 A3 ; case 2: goto A344; // Congratulations screen
8056: EE 94 ; case 3: goto 94EE; // Play and demo
8058: 95 9F ; case 4: goto 9F95; // Ending animation
; }

$00BD

मूल्य	विवरण
`00`	कानूनी के साथ स्क्रीन जानकारी और स्क्रीन सेवर
`01`	मेनू स्क्रीन
`02`	बधाई हो स्क्रीन
`03`	खेल और डेमो
`04`	अंत एनीमेशन

रेंडरिंग मोड का हिस्सा $03नीचे दिखाया गया है। जैसा कि आप नीचे देख सकते हैं, यह वीआरएएम में एक सूचकांक के साथ खेल के मैदान की एक पंक्ति से गुजरता है । यदि 20 से अधिक, सबरूटीन कुछ नहीं करता है। तालिका ( ) में सामान्य मोड में 6 द्वारा स्थानांतरित किए गए खेल फ़ील्ड की प्रदर्शित लाइनों और (2 और 12 अपूर्ण क्षेत्र 2 खिलाड़ी बनाम में खेल के मैदान के अनुरूप वीआरएएम पते शामिल हैं। इस तालिका के बाइट्स उन मानों की सूची का हिस्सा हैं जिन्हें 29 के स्तर के बाद ग़लती से संख्या के रूप में प्रदर्शित किया जाता है। प्रत्येक पते के आसन्न निचले और ऊपरी बाइट्स को अलग से प्राप्त किया जाता है और अनिवार्य रूप से एक 16-बिट पते में जोड़ा जाता है जो प्रतिलिपि चक्र में उपयोग किया जाता है। सबरूटीन के अंत में एक वेतन वृद्धि को अंजाम दिया जाता है।

952A: JSR $9725 ; copyPlayfieldRowToVRAM();
952D: JSR $9725 ; copyPlayfieldRowToVRAM();
9530: JSR $9725 ; copyPlayfieldRowToVRAM();
9533: JSR $9725 ; copyPlayfieldRowToVRAM();

copyPlayfieldRowToVRAM()vramRowvramRow

9725: LDX $0049 ; if (vramRow > 20) {
9727: CPX #$15 ; return;
9729: BPL $977E ; }

972B: LDA $96D6,X
972E: TAY ; playfieldAddress = 10 * vramRow;

972F: TXA
9730: ASL
9731: TAX
9732: INX ; high = vramPlayfieldRows[vramRow * 2 + 1];
9733: LDA $96EA,X
9736: STA $2006
9739: DEX

973A: LDA $00BE
973C: CMP #$01
973E: BEQ $975E ; if (numberOfPlayers == 2) {

9740: LDA $00B9
9742: CMP #$05
9744: BEQ $9752 ; if (leftPlayfield) {

9746: LDA $96EA,X
9749: SEC
974A: SBC #$02
974C: STA $2006 ; low = vramPlayfieldRows[vramRow * 2] - 2;

974F: JMP $9767 ; } else {

9752: LDA $96EA,X
9755: CLC
9756: ADC #$0C
9758: STA $2006 ; low = vramPlayfieldRows[vramRow * 2] + 12;

975B: JMP $9767 ; } else {

975E: LDA $96EA,X
9761: CLC
9762: ADC #$06 ; low = vramPlayfieldRows[vramRow * 2] + 6;
9764: STA $2006 ; }

; vramAddress = (high << 8) | low;

9767: LDX #$0A
9769: LDA ($B8),Y
976B: STA $2007
976E: INY ; for(i = 0; i < 10; i++) {
976F: DEX ; vram[vramAddress + i] = playfield[playfieldAddress + i];
9770: BNE $9769 ; }

9772: INC $0049 ; vramRow++;
9774: LDA $0049 ; if (vramRow < 20) {
9776: CMP #$14 ; return;
9778: BMI $977E ; }

977A: LDA #$20
977C: STA $0049 ; vramRow = 32;

977E: RTS ; return;

vramPlayfieldRows$96EA

vramRow। यदि मान 20 तक पहुंचता है, तो उसे 32 का मान दिया जाता है, जिसका अर्थ है कि प्रतिलिपि पूरी तरह से पूरी हो गई है। जैसा कि ऊपर दिखाया गया है, प्रति फ्रेम केवल 4 लाइनें कॉपी की जाती हैं।

राज्य हैंडलर $03को पूरी लाइनों को पहचानने और उन्हें खेल के मैदान से हटाने के लिए जिम्मेदार है। 4 अलग-अलग कॉल के दौरान, वह [−2, 1]टेट्रीमिनो के केंद्र के पास लाइन ऑफ़सेट्स को स्कैन करता है (टेट्रीमिनो के सभी वर्गों के दोनों निर्देशांक इस अंतराल में हैं)। पूर्ण पंक्तियों के अनुक्रमित पर संग्रहीत किया जाता है $004A- $004D; रिकॉर्ड किए गए सूचकांक 0 का उपयोग यह इंगित करने के लिए किया जाता है कि इस पास में कोई पूर्ण पंक्तियाँ नहीं मिलीं। हैंडलर नीचे दिखाया गया है। शुरुआत में चेक हैंडलर को वीआरएएम (राज्य हैंडलर) को खेल मैदान की लाइनों को स्थानांतरित करने पर निष्पादित करने की अनुमति नहीं देता है

9A6B: LDA $0049
9A6D: CMP #$20 ; if (vramRow < 32) {
9A6F: BPL $9A74 ; return;
9A71: JMP $9B02 ; }

9A74: LDA $0041 ; rowY = tetriminoY - 2;
9A76: SEC
9A77: SBC #$02 ; if (rowY < 0) {
9A79: BPL $9A7D ; rowY = 0;
9A7B: LDA #$00 ; }

9A7D: CLC
9A7E: ADC $0057
9A80: STA $00A9 ; rowY += lineIndex;

9A82: ASL
9A83: STA $00A8
9A85: ASL
9A86: ASL
9A87: CLC
9A88: ADC $00A8
9A8A: STA $00A8 ; rowIndex = 10 * rowY;

9A8C: TAY
9A8D: LDX #$0A
9A8F: LDA ($B8),Y
9A91: CMP #$EF ; for(i = 0; i < 10; i++) {
9A93: BEQ $9ACC ; if (playfield[rowIndex + i] == EMPTY_TILE) {
9A95: INY ; goto rowNotComplete;
9A96: DEX ; }
9A97: BNE $9A8F ; }

9A99: LDA #$0A
9A9B: STA $06F1 ; play row completed sound effect;

9A9E: INC $0056 ; completedLines++;

9AA0: LDX $0057
9AA2: LDA $00A9
9AA4: STA $4A,X ; lines[lineIndex] = rowY;

9AA6: LDY $00A8
9AA8: DEY
9AA9: LDA ($B8),Y
9AAB: LDX #$0A
9AAD: STX $00B8
9AAF: STA ($B8),Y
9AB1: LDA #$00
9AB3: STA $00B8
9AB5: DEY ; for(i = rowIndex - 1; i >= 0; i--) {
9AB6: CPY #$FF ; playfield[i + 10] = playfield[i];
9AB8: BNE $9AA9 ; }

9ABA: LDA #$EF
9ABC: LDY #$00
9ABE: STA ($B8),Y
9AC0: INY ; for(i = 0; i < 10; i++) {
9AC1: CPY #$0A ; playfield[i] = EMPTY_TILE;
9AC3: BNE $9ABE ; }

9AC5: LDA #$13
9AC7: STA $0042 ; orientationID = UNASSIGNED;

9AC9: JMP $9AD2 ; goto incrementLineIndex;

rowNotComplete:

9ACC: LDX $0057
9ACE: LDA #$00
9AD0: STA $4A,X ; lines[lineIndex] = 0;

incrementLineIndex:

9AD2: INC $0057 ; lineIndex++;

9AD4: LDA $0057 ; if (lineIndex < 4) {
9AD6: CMP #$04 ; return;
9AD8: BMI $9B02 ; }

9ADA: LDY $0056
9ADC: LDA $9B53,Y
9ADF: CLC
9AE0: ADC $00BC
9AE2: STA $00BC ; totalGarbage += garbageLines[completedLines];

9AE4: LDA #$00
9AE6: STA $0049 ; vramRow = 0;
9AE8: STA $0052 ; clearColumnIndex = 0;

9AEA: LDA $0056
9AEC: CMP #$04
9AEE: BNE $9AF5 ; if (completedLines == 4) {
9AF0: LDA #$04 ; play Tetris sound effect;
9AF2: STA $06F1 ; }

9AF5: INC $0048 ; if (completedLines > 0) {
9AF7: LDA $0056 ; playState = DISPLAY_LINE_CLEARING_ANIMATION;
9AF9: BNE $9B02 ; return;
; }

9AFB: INC $0048 ; playState = UPDATE_LINES_AND_STATISTICS;

9AFD: LDA #$07
9AFF: STA $06F1 ; play piece locked sound effect;

9B02: RTS ; return;

vramRow$03हर फ्रेम में कहा जाता है)। यदि भरी हुई पंक्तियों का पता लगाया जाता है, तो यह vramRow0 पर रीसेट हो जाता है, जो एक पूर्ण हस्तांतरण को मजबूर करता है।

lineIndex( $00A9) को 0 के मान के साथ आरंभीकृत किया जाता है और प्रत्येक वेतनवृद्धि में इसकी वृद्धि की जाती है।

गेम स्टेट $0Aऔर गेम फील्ड कॉपी रुटीन के विपरीत , जो एड्रेस गुणा तालिका का उपयोग करते हैं $96D6, एक ब्लॉक जो कि शिफ्ट और परिवर्धन का उपयोग करके 10 से $9A82गुणा rowYकरके शुरू होता है :

rowIndex = (rowY << 1) + (rowY << 3); // rowIndex = 2 * rowY + 8 * rowY;

यह केवल इसलिए किया जाता है क्योंकि यह rowYअंतराल द्वारा सीमित है [0, 20], और गुणा तालिका केवल कवर करती है [0, 19]। पंक्ति स्कैनिंग खेल के मैदान के अंत से आगे बढ़ सकती है। हालांकि, जैसा कि पहले कहा गया था, खेल एक मूल्य के साथ शुरू करता है $0400-$04FF$EF(खाली टाइल), खेल के मैदान के फर्श के नीचे 5 से अधिक अतिरिक्त खाली छिपी लाइनें बनाना।

के साथ शुरू होने वाला एक ब्लॉक $9ADA2 प्लेयर वर्सस के अधूरे मोड का हिस्सा है। जैसा कि ऊपर उल्लेख किया गया है, पंक्तियों को साफ़ करना प्रतिद्वंद्वी के खेल मैदान में मलबे को जोड़ता है। कचरा पंक्तियों की संख्या पते पर तालिका द्वारा निर्धारित की जाती है $9B53: पते पर चक्र भरा हुआ पंक्ति एक पंक्ति नीचे सामग्री को स्थानांतरित करता है। वह इस तथ्य का लाभ उठाता है कि निरंतर अनुक्रम में प्रत्येक पंक्ति को 10 बाइट्स से अलग किया जाता है। अगला लूप शीर्ष रेखा को साफ करता है। गेम स्टेट के दौरान पंक्ति स्पष्ट एनीमेशन किया जाता है , लेकिन जैसा कि नीचे दिखाया गया है, यह गेम स्टेट हैंडलर में नहीं होता है, जो पूरी तरह से खाली है।

9B53: 00 ; no cleared lines
9B54: 00 ; Single
9B55: 01 ; Double
9B56: 02 ; Triple
9B57: 04 ; Tetris

$9AA6

$04

9E39: RTS ; return;

इसके बजाय, खेल की स्थिति के दौरान $04, रेंडरिंग मोड का अगला ब्रांचिंग किया जाता है $03। और अधूरे मोड 2 प्लेयर वर्सेस के लिए मिरर किए गए मानों की आवश्यकता होती है। सबरूटीन को नीचे दिखाया गया है । इसे हर फ्रेम में कहा जाता है, लेकिन शुरुआत में स्थिति इसे केवल हर चौथे फ्रेम में निष्पादित करने की अनुमति देती है। प्रत्येक पास में, यह पूरी पंक्तियों के सूचकांकों की सूची के माध्यम से चक्र करता है और इन पंक्तियों में 2 स्तंभों को साफ करता है, केंद्रीय स्तंभ से बाहर की ओर बढ़ते हैं। एक 16-बिट VRAM पते का निर्माण उसी तरह से किया जाता है जैसे कि कॉपी फील्ड रूटीन में दिखाया जाता है। हालाँकि, इस स्थिति में, यह नीचे दी गई तालिका से प्राप्त कॉलम इंडेक्स द्वारा ऑफसेट करता है।

94EE: LDA $0068
94F0: CMP #$04
94F2: BNE $9522 ; if (playState == DISPLAY_LINE_CLEARING_ANIMATION) {

94F4: LDA #$04
94F6: STA $00B9 ; leftPlayfield = true;

94F8: LDA $0072
94FA: STA $0052
94FC: LDA $006A
94FE: STA $004A
9500: LDA $006B
9502: STA $004B
9504: LDA $006C
9506: STA $004C
9508: LDA $006D
950A: STA $004D
950C: LDA $0068
950E: STA $0048 ; mirror values;

9510: JSR $977F ; updateLineClearingAnimation();

; ...
; }

leftPlayfield

updateLineClearingAnimation()

977F: LDA $00B1 ; if (frameCounter not divisible by 4) {
9781: AND #$03 ; return;
9783: BNE $97FD ; }

9785: LDA #$00 ; for(i = 0; i < 4; i++) {
9787: STA $00AA ; rowY = lines[i];
9789: LDX $00AA ; if (rowY == 0) {
978B: LDA $4A,X ; continue;
978D: BEQ $97EB ; }

978F: ASL
9790: TAY
9791: LDA $96EA,Y
9794: STA $00A8 ; low = vramPlayfieldRows[2 * rowY];

9796: LDA $00BE ; if (numberOfPlayers == 2) {
9798: CMP #$01 ; goto twoPlayers;
979A: BNE $97A6 ; }

979C: LDA $00A8
979E: CLC
979F: ADC #$06
97A1: STA $00A8 ; low += 6;

97A3: JMP $97BD ; goto updateVRAM;

twoPlayers:

97A6: LDA $00B9
97A8: CMP #$04
97AA: BNE $97B6 ; if (leftPlayfield) {

97AC: LDA $00A8
97AE: SEC
97AF: SBC #$02
97B1: STA $00A8 ; low -= 2;

97B3: JMP $97BD ; } else {

97B6: LDA $00A8
97B8: CLC
97B9: ADC #$0C ; low += 12;
97BB: STA $00A8 ; }

updateVRAM:

97BD: INY
97BE: LDA $96EA,Y
97C1: STA $00A9
97C3: STA $2006
97C6: LDX $0052 ; high = vramPlayfieldRows[2 * rowY + 1];
97C8: LDA $97FE,X
97CB: CLC ; rowAddress = (high << 8) | low;
97CC: ADC $00A8
97CE: STA $2006 ; vramAddress = rowAddress + leftColumns[clearColumnIndex];
97D1: LDA #$FF
97D3: STA $2007 ; vram[vramAddress] = 255;

97D6: LDA $00A9
97D8: STA $2006
97DB: LDX $0052 ; high = vramPlayfieldRows[2 * rowY + 1];
97DD: LDA $9803,X
97E0: CLC ; rowAddress = (high << 8) | low;
97E1: ADC $00A8
97E3: STA $2006 ; vramAddress = rowAddress + rightColumns[clearColumnIndex];
97E6: LDA #$FF
97E8: STA $2007 ; vram[vramAddress] = 255;

97EB: INC $00AA
97ED: LDA $00AA
97EF: CMP #$04
97F1: BNE $9789 ; }

97F3: INC $0052 ; clearColumnIndex++;
97F5: LDA $0052 ; if (clearColumnIndex < 5) {
97F7: CMP #$05 ; return;
97F9: BMI $97FD ; }

97FB: INC $0048 ; playState = UPDATE_LINES_AND_STATISTICS;

97FD: RTS ; return;

97FE: 04 03 02 01 00 ; left columns
9803: 05 06 07 08 09 ; right columns

सफाई एनीमेशन के लिए, 5 पास आवश्यक हैं। फिर कोड अगले गेम की स्थिति में आगे बढ़ता है।

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

9C9E: LDA #$00
9CA0: STA $0056 ; completedLines = 0;

9CA2: INC $0048 ; playState = B_TYPE_GOAL_CHECK;

9CA4: RTS ; return;

completedLines$05completedLines$03पूर्ण पंक्तियों को स्कैन करना शुरू करता है। वह उन्हें completedLinesनहीं ढूंढेगा , लेकिन उन्हें अपरिवर्तित छोड़ देगा । अंत में, जब खेल की स्थिति पूरी हो जाती है, तो $05कुल पंक्तियों और स्कोर में वृद्धि होगी, जैसे कि आपने उन्हें स्कोर किया था।

ऐसा करने का सबसे आसान तरीका सबसे बड़ी राशि प्राप्त करना है, डेमो को टेट्रिस इकट्ठा करने के लिए इंतजार करना (डेमो में उनमें से 2 होंगे)। जैसे ही आप स्क्रीन झिलमिलाहट देखते हैं, स्टार्ट पर क्लिक करें।

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

9673: LDA #$3F
9675: STA $2006
9678: LDA #$0E
967A: STA $2006 ; prepare to modify background tile color;

967D: LDX #$00 ; color = DARK_GRAY;

967F: LDA $0056
9681: CMP #$04
9683: BNE $9698 ; if (completedLines == 4) {

9685: LDA $00B1
9687: AND #$03
9689: BNE $9698 ; if (frameCounter divisible by 4) {

968B: LDX #$30 ; color = WHITE;

968D: LDA $00B1
968F: AND #$07
9691: BNE $9698 ; if (frameCounter divisible by 8) {

9693: LDA #$09
9695: STA $06F1 ; play clear sound effect;

; }
; }
; }

9698: STX $2007 ; update background tile color;

holdDownPoints$004FholdDownPoints

खेल राज्य $06बी प्रकार के खेल के लिए एक लक्ष्य की जाँच करता है। ए-टाइप मोड में, यह अनिवार्य रूप से एक अप्रयुक्त फ्रेम है।

खेल राज्य $07में विशेष रूप से अपूर्ण 2 प्लेयर वर्सस लॉजिक है। एकल खिलाड़ी मोड में, यह अप्रयुक्त फ्रेम की तरह व्यवहार करता है।

खेल राज्य की $08चर्चा "बनाना Tetrimino" और "Tetrimino का चयन" में की जाती है।

खेल राज्य का $09उपयोग नहीं किया जाता है। $0Bखेल की स्थिति को बढ़ाता है, लेकिन अप्रयुक्त भी दिखता है।

और अंत में, खेल का मुख्य चक्र:

; while(true) {

8138: JSR $8161 ; branchOnGameMode();

813B: CMP $00A7 ; if (vertical blanking interval wait requested) {
813D: BNE $8142 ; waitForVerticalBlankingInterval();
813F: JSR $AA2F ; }

8142: LDA $00C0
8144: CMP #$05
8146: BNE $815A ; if (gameMode == DEMO) {

8148: LDA $00D2
814A: CMP #$DF
814C: BNE $815A ; if (reached end of demo table) {

814E: LDA #$DD
8150: STA $00D2 ; reset demo table index;

8152: LDA #$00
8154: STA $00B2 ; clear upper byte of frame counter;

8156: LDA #$01
8158: STA $00C0 ; gameMode = TITLE_SCREEN;
; }
; }
815A: JMP $8138 ; }

$ 00	`$02`	`$07`	`$08`	`$0A`	`$0B`	`$0E`	`$12`
0	2	0	1	3	4	0	4
1	3	1	2	4	5	1	5
2	4	2	3	5	6	2	6
3	5	3	4	6	0	3	0
4	6	4	5	0	1	4	1
5	0	5	6	1	2	5	2
6	1	6	0	2	3	6	3
7	2	0	1	3	4	0	4

0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19
10	20	30	40	50	60	70	80	90	100	110	120	130	140	150	160	170	180	190	200
10	20	30	40	50	60	70	80	90	100	100	100	100	100	100	100	110	120	130	140

$ 00	`$02`	`$07`	`$08`	`$0A`	`$0B`	`$0E`	`$12`
0	2	0	1	3	4	0	4
1	3	1	2	4	5	1	5
2	4	2	3	5	6	2	6
3	5	3	4	6	0	3	0
4	6	4	5	0	1	4	1
5	0	5	6	1	2	5	2
6	1	6	0	2	3	6	3
7	2	0	1	3	4	0	4

0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19
10	20	30	40	50	60	70	80	90	100	110	120	130	140	150	160	170	180	190	200
10	20	30	40	50	60	70	80	90	100	100	100	100	100	100	100	110	120	130	140

कैसे मैंने एई को एनईएस के लिए टेट्रिस खेलना सिखाया। भाग 1: खेल कोड का विश्लेषण