🗡️ 👨🏼‍🏫 📌 [एनईएस] हम फारस के राजकुमार के लिए एक स्तर के संपादक लिख रहे हैं। अध्याय एक परिचित 💔 👨🏼‍🍳 💾

अध्याय एक , अध्याय दो , अध्याय तीन , अध्याय चार , अध्याय पाँच , उपसंहार

त्याग

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

कुछ खेलों ने एक अंतर्निहित स्तर के संपादक (उदाहरण के लिए, बैटल सिटी, फायर'एन'एस उर्फ सोलोमन की की 2) को प्रदान किया, लेकिन उनमें से ज्यादातर ने ऐसा अवसर प्रदान नहीं किया। मैं खेलना चाहता था (स्वाभाविक रूप से!) नया सुपर मारियो ब्रदर्स (ओह, मैं कैसे प्यार करता था और चीनी से नफरत करता था जिसने 99 को जारी किया ... 9 इन 1 कारतूस, जिसमें ए -1, बी -1, ... जेड -1 के स्तर थे, जो असंभव थे पास करना था, या जो मूल स्तरों के डुप्लिकेट थे, लेकिन परिवर्तित बनावट के साथ), डक टेल्स 1, 2 और कई अन्य।

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

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

एनईएस और इसके अनुकरण पर विभिन्न प्रकार के संसाधन मेरी समझ में देने के लिए बहुत इच्छुक नहीं थे और मैं नोब स्तर पर कहीं न कहीं बना रहा।

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

मैंने शुरू किया ... हालाँकि, इससे पहले कि मैं आगे बताना शुरू करूँ, मैं सावधानी:
पेशेवरों के लिए कटौती के तहत जाने की सिफारिश नहीं की जाती है। एक शुरुआत के "चमकती" विधियों पर विचार किया जाता है! आपका तंत्रिका तंत्र अपरिवर्तनीय रूप से क्षतिग्रस्त हो सकता है! मैंने चेतावनी दी।

सार में तल्लीनता

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

एनईएस हेडर

यह पहली चीज है जो सतह पर स्थित है। चलो उसके साथ शुरू करते हैं।
शीर्षलेख में 16 बाइट्स का आकार होता है, जहां हस्ताक्षर के अलावा ROM फ़ाइल के बारे में तकनीकी जानकारी होती है। एक ROM फ़ाइल अपने आप में एक फ़ाइल में डेटा और तकनीकी जानकारी का एक संयोजन है। हेडर के अंदर एक नज़र डालें।
4E 45 53 1A 08 00 21 00 00 00 00 00 00 00 00 00
4 बाइट्स: हस्ताक्षर एनईएस->;
1 बाइट: 16 KB PRG-ROM बैंकों की संख्या;
1 बाइट: 8 केबी सीएचआर-रोम बैंकों की संख्या;
2 बाइट्स: झंडे;
1 बाइट: 8 केबी पीआरजी-आर ए एम बैंकों की संख्या;
2 बाइट्स: झंडे;
शेष पूंछ शून्य है।

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

हेडर से हमें पता चलता है कि हमारे पास Mapper # 2 (एक मैपर संख्या वाला एक बाइट आधा छठे और सातवें बाइट्स से बना है) और 8 16 kB PRG-ROM बैंक हैं। बाकी सब गायब है।

प्रलेखन से यह निम्नानुसार है कि PRG-ROM बैंक वास्तव में एक कोड + मनमाना डेटा है जो सीधे सीपीयू द्वारा उपयोग किया जाएगा। CHR-ROM बैंक वीडियो सबसिस्टम (PPU) के लिए डेटा हैं। सीपीयू सीधे उनसे संपर्क नहीं कर सकता है।
यदि हमारे पास एक भी CHR-ROM नहीं है तो हमें एक छवि कैसे मिलेगी? बहुत सरल: PRG में, हम उन डेटा को संग्रहीत करते हैं जो लगातार PPU मेमोरी में कॉपी किए जाते हैं। असहज? हां। लेकिन इस डेटा पर, एक मायने में, हमारे पास अधिक शक्ति है।

इसके अलावा, हमें पता चला है कि मैपर # 2 वास्तव में कई अलग-अलग मैपर्स का अर्थ है, कार्यक्षमता में समान लेकिन संरचना में अलग: UNROM और UOROM, UxROM में नाम से एकजुट हैं। अंतर केवल PRG-ROM बैंकों की संख्या में है: पहले में 8 बैंक हैं, दूसरे में - 16. उनमें से किसी के लिए, अंतिम बैंक RAM के अंत में तय किया गया है ($ C000- $ FFFF), और शेष 7 (या दूसरे मामले के लिए 15) को स्विच किया जा सकता है। $ 8000- $ BFFF के मेमोरी क्षेत्र में।
यह सभी तकनीकी जानकारी है, जो फिलहाल हमें कुछ भी समझदार नहीं बताती है।

हम डिब्बाबंद भोजन का स्टॉक करते हैं

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

लेकिन, जब हम विकल्पों का पता लगा लेंगे, तो हमें बाइनरी दलिया के पूरे टुकड़ों से क्या मिलेगा।

सबसे जटिल, लेकिन यह भी सबसे सार्वभौमिक: अनुक्रमिक रिवर्स कोड डीबगर। इस पद्धति का उपयोग करके, हमें निश्चित रूप से वह मिलेगा जो हमें चाहिए, कोड के निर्माण के बारे में अतिरिक्त जानकारी के रूप में रास्ते में बोनस प्राप्त करना। खनिक स्पष्ट हैं: हम रिवर्स पर बहुत समय बिताएंगे, लेकिन यह इतना बुरा नहीं है, क्योंकि हम अभी भी कुछ भी नहीं जानते हैं, जिसका अर्थ है कि हम कोडांतरक का अध्ययन करने और उस पर विभिन्न प्रोग्रामिंग "ट्रिक्स" का 90% समय व्यतीत करेंगे। यानी दक्षता लगभग 10% होगी। पर्याप्त नहीं है;
रैम का अध्ययन करना और फिर मेमोरी एक्सेस करने के लिए ब्रेकप्वाइंट को डीबग करना (नीचे देखें)। यह तरीका पहले से बेहतर है। हमारे पास अध्ययन करने के लिए अपेक्षाकृत कम मेमोरी है: 64 केबी उपलब्ध मेमोरी में, हम में से आधे रोम फ़ाइल से बैंकों में जाते हैं, इस आधे का आधा या तो आरक्षित है या आईओ बंदरगाहों द्वारा उपयोग किया जाता है। और अंत में, शेष आधा अभी भी आधे में धड़क रहा है। एक आधा PPU के लिए IO पोर्ट है (उनमें से कई नहीं हैं, लेकिन वे पूरे आधे हिस्से के लिए प्रतिबिंबित हैं), और दूसरे को 2 kB के चार भागों में विभाजित किया गया है। पहला भाग कोड द्वारा प्रयुक्त वास्तविक रैम है, और शेष तीन पहले भाग के दर्पण हैं। इस प्रकार, हमारे पास अध्ययन के लिए 2 kB स्मृति शेष है, जिसका अध्ययन सीधे मेरी आँखों से किया जा सकता है। विधि की दक्षता अधिक है, क्योंकि हमारी आंखों के सामने लाइव डेटा होगा जिसे हम रनटाइम पर सही बदल सकते हैं और परिणाम पर सही देख सकते हैं;
पढ़ने के डेटा का अध्ययन। दूसरे स्तर पर जाने या दूसरे कमरे में जाने के समय, हम उस डेटा का अध्ययन करते हैं जो ROM फ़ाइल से पढ़ा गया था। जैसा कि हम याद करते हैं, फारस के राजकुमार में, प्रत्येक स्तर को उन कमरों में विभाजित किया जाता है जिनके बीच यह चलता है;
"परत" विधि "Bruteforce" है: हम क्रमिक रूप से एक बाइट को बदलते हैं, परिणाम का स्क्रीनशॉट लेते हैं, और हम स्क्रीनशॉट का एक गुच्छा क्यों अध्ययन करते हैं।

हम आवश्यक मात्रा में सामग्री का स्टॉक करते हैं और इसके अध्ययन के लिए आगे बढ़ते हैं। हम रिवर्स ऑर्डर में अध्ययन करेंगे: सरल से सीखने के लिए (केवल स्क्रीनशॉट को देखें) से जटिल (डीबगर लिस्टिंग का अध्ययन करें)।

उपकरणों के साथ सशस्त्र:

सहायक उपयोगिताओं के लेखन के लिए पसंदीदा पीएल। यह कुछ भी हो सकता है। मैंने VS2010 के भाग के रूप में C ++ का उपयोग किया;
डिबगर वाला एमुलेटर। मैंने FCEUX एमुलेटर की विभिन्न शाखाओं के संस्करणों का उपयोग किया। FCEUX और FCEUXDSP। पहले वाले के पास एक सरल अनाड़ी डिबगर है जो बहुत सरल चीजें कर सकता है। दूसरे के पास डिबगिंग और मेमोरी का अध्ययन करने के लिए बहुत शक्तिशाली उपकरण हैं, लेकिन दुर्भाग्य से यह अक्सर दुर्घटनाग्रस्त हो जाता है, इसलिए सरल मामलों में मैंने पहले का सहारा लिया;
कोई हेक्स संपादक। मैंने WinHEX का उपयोग किया, जो आपको फ़ाइल को सहेजे बिना इसे चलाने की अनुमति देता है (किसी भी बाइट को संपादित करें और Ctrl + E दबाएं)।
कोड पर मदद के लिए, आप NES बूटलोडर के साथ IDAPro का उपयोग कर सकते हैं। आप cah4e3 से बूटलोडर का उपयोग कर सकते हैं। लेकिन उससे चमत्कार की अपेक्षा न करें, क्योंकि निष्पादन के दौरान बैंक गतिशील रूप से बदलते हैं, और सही कोड केवल अंतिम बैंक से होगा।

शुरू करने से पहले, आइए देखें कि UxROM क्या है:
सामान्यतया, मैपर एम्यूलेटर के दृष्टिकोण से एक एल्गोरिथ्म है, और लोहे के दृष्टिकोण से यह एक प्रकार का नियंत्रक है जो मेमोरी में बैंकों को स्विच करने से संबंधित है।
पहला: वह ऐसा क्यों कर रहा है?
दूसरी बात: वह यह कैसे करता है?

पहले प्रश्न का उत्तर सरल है: बहुत अधिक रैम नहीं है जिसे प्रोसेसर केवल 64 kB को संबोधित कर सकता है, और न केवल कोड और डेटा, बल्कि इनपुट / आउटपुट पोर्ट्स, साथ ही अन्य चीजों का एक गुच्छा (जैसे कि गैर-वाष्पशील मेमोरी जो इसे संग्रहीत है) में धकेल दिया जाना चाहिए। कुछ खेलों के मध्यवर्ती परिणाम)। हमें एक सरल समाधान मिला: जैसे-जैसे कोड चलता है, काम के लिए मेमोरी में सभी डेटा की आवश्यकता नहीं होती है, इसलिए आप बस इसे बाहर कर सकते हैं, और एक निश्चित समय में उनकी जगह पर अधिक महत्वपूर्ण डाल सकते हैं। रॉम-मेमोरी के आगे, कारतूस पर एक नियंत्रक स्थापित किया गया था, जो कमांड पर, पता मेमोरी में वांछित टुकड़ा प्रदर्शित करता है। खेल की जटिलता के आधार पर, ये नियंत्रक उनके भरने में भिन्न होते हैं। दूसरी ओर, चीनी ने इस व्यवसाय को समय पर उठाया और कई अलग-अलग (पर्याप्त और ऐसा नहीं) मैपर के साथ आया। इसके लिए धन्यवाद, हमारे पास बड़ी संख्या में मल्टीगैम हैं।

दूसरे प्रश्न में, हम केवल UxROM मैपर के संचालन पर विचार करेंगे, क्योंकि बाकी अब हमारे लिए दिलचस्प नहीं हैं। मैपर अंतिम बैंक (# 07 या # 0F) लेता है, इसे $ C000- $ FFFF के पते पर रखता है और अब इसे नहीं छूता है। अन्य सभी बैंकों को रिकॉर्डिंग के बाद आवश्यकतानुसार (सामान्य मामले में) $ C000- बैंक नंबर के FFFF $ (# 00- # 06 या # 00- # 0E) से किसी भी पते पर शामिल किया जाता है। लेकिन यह निम्नानुसार सही ढंग से किया गया है: पते पर $ FFF0 + N, N लिखा है, जहां N बैंक नंबर है, और परिणामस्वरूप, पते पर $ 8000- $ BFFF, हम वांछित बैंक की सामग्री देखते हैं।

हम जार को कुल्हाड़ी से काटते हैं। विधि संख्या 4।

ऐसा करने के लिए, एक छोटी उपयोगिता लिखी गई थी जिसने एक बाइट (साधारण वृद्धि: बाइट ++) को बदल दिया, एक अलग फ़ाइल में सहेजा, फिर एमुलेटर में प्राप्त रॉम को लॉन्च किया, एक स्क्रीनशॉट लिया और एमुलेटर को बंद कर दिया।
स्क्रीनशॉट की संख्या को कम करना बुद्धिमानी होगी, क्योंकि 130,000 से अधिक स्क्रीनशॉट का अध्ययन करना, यहां तक कि एक सरसरी तौर पर भी मुश्किल होगा।

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

तो ठीक है। इस तरह से हमें जो डेटा चाहिए, वह कैसे मिल सकता है? बहुत सरल: स्क्रीनशॉट पर एक त्वरित नज़र, हम देखेंगे कि उनमें से कुछ पर, हम धीरे-धीरे कमरों में ब्लॉक बदलते हैं। कमरे में क्रमशः 10x3 ब्लॉक होते हैं, एक पंक्ति में 30 स्क्रीनशॉट में, हमें (लेकिन नहीं करना चाहिए!) आसन्न ब्लॉकों को कुछ अन्य लोगों में बदलें: उदाहरण के लिए, एक "कंक्रीट" ब्लॉक को स्तंभ या कुछ और के लिए बदला जा सकता है।

हम कहीं पर छँटाई उपयोगिता शुरू करते हैं, और हम स्वयं ROM से पढ़े गए डेटा का अध्ययन करने के लिए आगे बढ़ते हैं।

हम एक क्लेवर के साथ ढक्कन को काट सकते हैं। विधि संख्या 3।

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

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

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

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

शुरू करने के लिए, हम प्रलेखन से कुछ बिंदुओं को उजागर करते हैं:

संबोधित करना प्रत्यक्ष रजिस्टर हो सकता है <-> मेमोरी (आईएमएम): एलडीए $ 00; एसटीए $ 00;
प्रत्यक्ष सूचकांक सूचकांक शामिल: रजिस्टर <-> मेमोरी + INDEX: LDA $ 0000, X; एसटीए $ 0000, वाई;
अप्रत्यक्ष सूचकांक रजिस्टर शामिल: रजिस्टर <-> सूचक + INDEX: LDA ($ 00), एक्स; एसटीए ($ 00), वाई;

अप्रत्यक्ष रूप से संबोधित करते हुए, प्रोसेसर दो कोशिकाओं से 16-बिट पॉइंटर निकालता है (प्रथम मेमोरी पेज $ 00- $ एफएफ के भीतर), इसमें इंडेक्स रजिस्टर का मूल्य जोड़ता है, और फिर इस प्रकार प्राप्त पते पर सेल के साथ काम करता है।

यहाँ से हम निम्नलिखित छद्म कोड सम्मेलनों की रचना करते हैं:

$ XXXX (जहां XXXX इसका पता है) के रूप में चर को अस्वीकार करें;
#XXXX [Y] के रूप में प्रत्यक्ष पते को अस्वीकार करें (जहां XXXX वह पता है जहां से हम संबोधित कर रहे हैं)। एनालॉग: * ((चार *) (XXXX + वाई)) = ए;
अप्रत्यक्ष संबोधन को XXXX [Y] के रूप में दर्शाया गया है (C में सरणियों के साथ एक पूर्ण सादृश्य);
हमारे पास सभी प्रक्रियाएँ समान हैं: char sub_XXXX () {}। चूँकि एनईएस के पास तर्कों को पारित करने के लिए कोई सम्मेलन नहीं है, इसलिए हमारे पास तर्क नहीं होंगे। कोई भी डेटा, एक नियम के रूप में, रजिस्टरों के माध्यम से या चर के माध्यम से प्रसारित किया जाता है।
रजिस्टरों के मूल नाम (ए, एक्स, वाई) हैं।
HEX में #XX के रूप में आठ-बिट नंबर लिखे जाएंगे

एक साधारण बैंक स्विच कोड लें:

 $F2D3:84 41 STY $0041 = #$00 $F2D5:A8 TAY $F2D6:8D D1 06 STA $06D1 = #$06 $F2D9:99 F0 FF STA $FFF0,Y @ $FFF0 = #$00 $F2DC:A4 41 LDY $0041 = #$00 $F2DE:60 RTS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

आइए लाइन का अनुवाद लाइन से करने की कोशिश करते हैं:

 char switch_bank() //       A { $0041 = Y; //  Y Y = A; $06D1 = A; //     #FFF0[Y] = A; //       $FFF0+N  N ( N -   ) Y = $0041; //   Y return A; }

अब एक और अधिक जटिल कोड लेते हैं:

 ;;         PPU $F302:20 D3 F2 JSR $F2D3 $F305:8E 06 20 STX $2006 = #$41 $F308:A9 00 LDA #$00 $F30A:8D 06 20 STA $2006 = #$41 $F30D:A2 10 LDX #$10 $F30F:A0 00 LDY #$00 $F311:B1 17 LDA ($17),Y @ $020E = #$03 $F313:8D 07 20 STA $2007 = #$00 $F316:C8 INY $F317:D0 F8 BNE $F311 $F319:E6 18 INC $0018 = #$02 $F31B:CA DEX $F31C:D0 F1 BNE $F30F $F31E:4C 10 D0 JMP $D010 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

अनुवाद का पहला चरण:

 char sub_F302() { sub_F2D3(); // switch bank. Bank counter in A register // $2006 – PPU Address register // $2007 – PPU data write //  $2006     // ( ,  ) // 2007       //  PPU.     PPU //    1. $2006 = X; //    $2006 = #00 //    X = #10; label_F30F: Y = #00; label_F311: //   $0017:$0018   // ,  ,     PPU $2007 = $0017[Y]; Y++; if ( Y != #00 ) goto label_F311; $0018++; X--; if ( X != #00 ) goto label_F30F; return sub_F2D3(#05); //  5-  }

और अनुवाद का अंतिम चरण:

 void WriteDataIntoPPU(char Bank, char PPULine) { switch_bank(Bank); // switch bank. PPUADDRESS = PPULine; //    PPUADDRESS = #00; //    for(X = #10; X > 0; X--) { for(Y = #00; Y <= #FF; Y++) { PPUDATA = $Tiles[Y]; } $Tiles += #100; //     } return switch_bank5(); }

दो सरल चरणों में, हमने हार्ड-टू-रीड (शुरुआती के लिए) कोडांतरक लिस्टिंग को समझने योग्य कोड में फिर से लिखा है। मैंने switch_bank5 प्रक्रिया पर विचार नहीं किया, A को पंजीकृत करने के लिए संख्या # 05 निर्दिष्ट करने के लिए एक सामान्य कोड है, और फिर सब_F2D3 बैंक स्विचिंग प्रक्रिया को कहा जाता है। मेरे लिए स्वचालित प्रक्रिया विकसित करने के लिए तीन प्रक्रियाओं की एक जोड़ी पर्याप्त थी जब कोड को पठनीय कोड में अनुवाद किया जाता है, तो सब कुछ बहुत सरल हो जाता है। जब मैंने लगभग दस से 5-7 केबी पाठ फ़ाइलों को जमा किया था, तो मुझे अब कोड का अनुवाद करने की आवश्यकता नहीं थी - मेरे सिर में सब कुछ अपने आप होने लगा।

हम गुलदस्ता और कैंडी अवधि के लिए पास करते हैं

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

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

[एनईएस] हम फारस के राजकुमार के लिए एक स्तर के संपादक लिख रहे हैं। अध्याय एक परिचित