🚣🏼 〽️ ✴️ [एनईएस] हम फारस के राजकुमार के लिए एक स्तर के संपादक लिख रहे हैं। अध्याय पाँच प्रतिबिंब 🧕 👩 🗨️

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

त्याग

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

शुक्रवार से शनिवार की रात को, मैंने फिर डिबगर खोला, RAM Filter, और खोज शुरू की ...

जन्म

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

यही है, कमरे में वस्तुओं की उपस्थिति किसी तरह की उपस्थिति / दोहरी की अनुपस्थिति को प्रभावित करती है। गार्डों के साथ सबकुछ स्पष्ट है - उनकी व्यवस्था सीधे स्तर के शीर्षक में बताई गई है, लेकिन डबल के बारे में कोई जानकारी नहीं है। स्तर 4, 5 और 6 के लिए डेटा सरणियाँ उनके सार में अन्य सभी से अलग नहीं थीं। पूरी तरह से नकल पांचवें स्तर, कहते हैं, पहले, इंजन कोड के आंत्र से एक डबल "कारण" नहीं था, जिसका अर्थ है कि यह किसी तरह इंजन में ही सिल दिया गया था। यह समझना आवश्यक था कि अगर हम एक डबल के साथ एक कमरे में प्रवेश करते हैं तो क्या परिवर्तन होता है।

मैंने पाँचवें स्तर का अध्ययन करना शुरू किया, क्योंकि वहाँ डबल ने सभी कार्यों का सबसे अधिक प्रदर्शन किया: यदि आप बाहर निकलने वाले बटन पर क्लिक करते हैं, तो वह प्रकट होता है, बोतल की कीमती सामग्री पीता है, और भाग जाता है। रैम फ़िल्टर ने एक असामान्य गतिविधि का पता लगाया जब पते के क्षेत्र में एक डबल मेमोरी में दिखाई दिया $ 0400- $ 0410: कमरे में प्रवेश करते समय, सेल $ 0401 में एक झंडा उठाया गया था, बटन पर क्लिक करने के बाद, सेल में एक ध्वज 0402 डॉलर को अतिरिक्त रूप से उठाया गया था, और फिर, इसके बाद कमरे से भाग गया। सेल $ 0401 रीसेट किया गया था और अब बदल नहीं गया है। इसलिए, हम अध्ययन करेंगे कि यहां क्या हो रहा है।

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

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

$A1D0:A9 00 LDA #$00 $A1D2:8D 01 04 STA $0401 = #$00 $A1D5:A5 51 LDA $0051 = #$17 $A1D7:8D DE 04 STA $04DE = #$17 $A1DA:AD 02 04 LDA $0402 = #$00 $A1DD:D0 4D BNE $A22C $A1DF:A9 3D LDA #$3D $A1E1:85 2F STA $002F = #$2D $A1E3:A9 A2 LDA #$A2 $A1E5:85 30 STA $0030 = #$A2 $A1E7:A5 70 LDA $0070 = #$04 $A1E9:C9 05 CMP #$05 $A1EB:D0 04 BNE $A1F1 $A1ED:A5 51 LDA $0051 = #$17 $A1EF:F0 2D BEQ $A21E $A1F1:A9 4D LDA #$4D $A1F3:85 2F STA $002F = #$2D $A1F5:A9 A2 LDA #$A2 $A1F7:85 30 STA $0030 = #$A2 $A1F9:AD FD 04 LDA $04FD = #$00 $A1FC:D0 0C BNE $A20A $A1FE:A5 70 LDA $0070 = #$04 $A200:C9 03 CMP #$03 $A202:D0 06 BNE $A20A $A204:A5 51 LDA $0051 = #$17 $A206:C9 03 CMP #$03 $A208:F0 14 BEQ $A21E $A20A:A9 2D LDA #$2D $A20C:85 2F STA $002F = #$2D $A20E:A9 A2 LDA #$A2 $A210:85 30 STA $0030 = #$A2 $A212:A5 70 LDA $0070 = #$04 $A214:C9 04 CMP #$04 $A216:D0 14 BNE $A22C $A218:A5 51 LDA $0051 = #$17 $A21A:C9 17 CMP #$17 $A21C:D0 0E BNE $A22C $A21E:A9 01 LDA #$01 $A220:8D 01 04 STA $0401 = #$00 ;; <<<  $A223:8D E0 06 STA $06E0 = #$00 $A226:20 AD F2 JSR $F2AD $A229:20 85 DB JSR $DB85 $A22C:60 RTS

इस शीट को समझना काफी मुश्किल है, इसलिए मैं इसे छद्म कोड में तब्दील कर दूंगा, इस प्रकार कोशिकाओं को कॉल कर रहा हूं:
- $ 70 - स्तर;
- $ 51 - ROOM;
- $ 401 - MIRROR_FLAG।
हम बाद में आराम करेंगे:

 char sub_A1D0() { MIRROR_FLAG = 0; $04DE = ROOM; if ( $0402 ) goto label_A22C; $2F = #3D; $30 = #A2; if ( LEVEL != #05 ) goto label_A1F1; if ( !ROOM ) goto label_A21E; label_A1F1: $2F = #4D; $30 = #A2; if ( $04FD ) goto label_A20A; if ( LEVEL != #03 ) goto label_A20A; if ( ROOM == #03 ) goto label_A21E; label_A20A: $2F = #2D; $30 = #A2; if ( LEVEL != #04 ) goto label_A22C; if ( ROOM != #17 ) goto label_A22C; label_A21E: MIRROR_FLAG = $06E0 = #01; sub_F2AD(); sub_DB85(); label_A22C: return; }

अब यह सीखना आसान है। जैसा कि आप देख सकते हैं, यहां बिल्कुल उन स्तरों और कमरों में जहां डबल दिखाई देता है, इसकी उपस्थिति का झंडा सेट है और दो और प्रक्रियाओं को कहा जाता है। मैं उन्हें नहीं लाऊंगा, मैं केवल उनका वर्णन करूंगा कि वे क्या कर रहे हैं।
- $ F2AD - $ 060E से शुरू होने वाले डबल #FF टोकन की खोज करता है, फिर $ Y60E और #FFFF टोकन (अंतिम में शामिल नहीं) के बीच बाइट अनुक्रम की लंबाई रजिस्टर Y में देता है;
- $ DB85 - बाइट अनुक्रम की एक शिफ्ट करता है, पिछली प्रक्रिया द्वारा पाया गया #FFFF मार्कर के साथ शुरू होता है, आगे, अनुक्रम की लंबाई से, जिसका पता कोशिकाओं में $ 2F: $ 30 में संग्रहीत होता है, और जो #FFFF मार्कर के साथ समाप्त होता है।
कोशिकाओं में $ 2F और $ 30, जैसा कि हम देखते हैं, हार्ड-कोडेड पते ROM में कहीं दर्ज किए गए हैं: $ A22D, $ A23D, $ A24D।

बस सेल में एक यूनिट को $ 0401 में जोड़ना पर्याप्त नहीं है, फिर भी आपको कुछ जादुई क्रियाएं करने की आवश्यकता है।

कास्केट के दो, चेहरे से समान

चूंकि डबल केवल तब दिखाई देता है जब सेल 0402 में ध्वज उठाया जाता है, हम पहले यह देखेंगे कि इसे कहां लिखना है, और फिर जहां से मूल्य पढ़ा गया है। ध्वज को उम्मीद के अनुसार उठाया जाता है, जब हम उस बटन पर क्लिक करते हैं जो निकास को खोलता है (दिलचस्प कुछ भी नहीं है)। लेकिन सेल से पढ़ना यहाँ किया जाता है:

 $A319:A9 89 LDA #$89 $A31B:85 72 STA $0072 = #$89 $A31D:A9 A3 LDA #$A3 $A31F:85 73 STA $0073 = #$A3 $A321:AD 02 04 LDA $0402 = #$01 ;; <<  $A324:F0 53 BEQ $A379 $A326:AD 01 04 LDA $0401 = #$01 $A329:F0 4E BEQ $A379 $A32B:EE 04 04 INC $0404 = #$00 $A32E:AC 03 04 LDY $0403 = #$00 $A331:B1 72 LDA ($72),Y @ $A389 = #$15 $A333:C9 FF CMP #$FF $A335:F0 43 BEQ $A37A $A337:CD 04 04 CMP $0404 = #$01 $A33A:D0 0B BNE $A347 $A33C:A9 00 LDA #$00 $A33E:8D 04 04 STA $0404 = #$01 $A341:EE 03 04 INC $0403 = #$00 $A344:EE 03 04 INC $0403 = #$00 $A347:C8 INY $A348:B1 72 LDA ($72),Y @ $A389 = #$15 ;; ...

उल्लेखनीय प्रक्रिया, है ना? उसके कार्यों का सार, यदि आप इसका संपूर्णता में अध्ययन करते हैं, तो यह उस प्रक्रिया के समान है जो डेमो प्ले में हमारे लिए खेलता है। $ 72: $ 73 सेल में हमारे पास $ A389 का पता है:
15 01 06 0D 02 02 03 32 0C 4E 02 05 17 01 FF
एक ही मार्कर # एफएफ, दो बाइट्स वाली समान संरचनाएं, जहां उनमें से पहला समय है, और दूसरा ... नहीं, दूसरा अब गेमपैड की नकल नहीं है, बल्कि कुछ और है। जब सेल की गणना $ 0404 में संरचना के पहले बाइट के साथ की जाती है, तो सेल $ 0403 में काउंटर 2 से बढ़ जाता है और प्रक्रिया दोहराती है। यदि हम दूसरी बाइट के साथ इस प्रक्रिया के दौरान देखते हैं, तो हम एक निश्चित बिंदु पर आएंगे:
0x15602: 00 00 AE 96 DB 96 64 97 9D 97 ...
इस सरणी में अनुक्रमणिका हमारी दूसरी बाइट होगी। इस सरणी में प्रत्येक सूचक एक संरचना को इंगित करता है जिसके साथ इंजन काफी मुश्किल काम करता है। यदि इस संरचना में एक मान पाया जाता है जो एक निश्चित संख्या से अधिक है, तो इसे एक इंडेक्स में डिकोड किया जाता है, जिसका उपयोग कोड की कुछ प्रक्रियाओं में पॉइंटर्स की एक सरणी में किया जाता है। यदि संख्या एक निश्चित संख्या से कम है, तो इसका उपयोग उपरोक्त प्रक्रियाओं के लिए एक तर्क के रूप में किया जाता है। ये प्रक्रियाएं, कुछ क्रियाएं करते हुए, चरित्र के लिए जिम्मेदार संरचना में निम्नलिखित सूचक का परिचय देती हैं। इस प्रकार, एक निश्चित शुरुआत सूचक को चरित्र संरचना में सेट करने के बाद, एक स्व-विनियमन चक्र शुरू होता है, जो स्प्राइट को गति में सेट करता है। उदाहरण के लिए, यदि हम संरचना में एक "रन" एक्शन पॉइंटर लिखते हैं, तो रन का प्रत्येक चरण पिछले एक द्वारा शुरू किया जाएगा, प्रत्येक पुनरावृत्ति के दौरान एक्शनप्रट क्षेत्र में एक ही संरचना में एक नया पॉइंटर सेट किया जाएगा। इसके अलावा, इन प्रक्रियाओं में, स्प्राइट को स्क्रीन पर स्थानांतरित किया जाएगा और इसके कार्यों को आवाज दी जाएगी।

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

'ड्राइव' डबल का पूर्ण कोड (छद्म कोड में)

 char sub_A25D() { if ( !MIRROR_FLAG ) goto label_A277; $06E0 = MIRROR_FLAG; if ( level == #03 ) goto label_A28D; if ( level != #04 ) goto label_A272; goto label_A319; label_A272: // here CMP #05 goto label_A398; label_A277: return; label_A278: $0072 = #86; $0073 = #A3; $04FE = #00; MIRROR.Y.LOW = #40; return sub_A326(); label_A28D: $04FB = $0402 = #00; MIRROR.DIRECTION = #FF; if ( room != #03 ) goto label_A2CF; if ( $04FD ) goto label_A278; if ( PRINCE.Y.LOW >= #48 ) goto label_A2CF; $04FB = $04FC; // if prince around mirror (by Y pos) if ( !$04FB ) goto label_A2C3; if ( PRINCE.X.HI ) goto label_A2C3; if ( PRINCE.X.LOW <= #AC ) goto label_A2D0; label_A2C3: A = #02; Y = #0E; sub_CAFD(); MIRROR.X.HI = #02; label_A2CF: return; label_A2D0: X = #98; if ( !PRINCE.DIRECTION ) goto label_A2D9; X = #94; label_A2D9: MIRROR.X.LOW = X; MIRROR.X.HI = #00; MIRROR.Y.LOW = PRINCE.Y.LOW; if ( PRINCE.ACTION_INDEX == #06 ) goto label_A2C3; if ( PRINCE.POSE_INDEX <= #06 ) goto label_A2F9; if ( PRINCE.POSE_INDEX <= #0E ) goto label_A301; label_A2F9: if ( PRINCE.POSE_INDEX <= #20 ) goto label_A302; if ( PRINCE.POSE_INDEX >= #28 ) goto label_A302; label_A301: return; label_A302: X = #00; Y = #05; label_A306: MIRROR.ACTION_PTR = PRINCE.ACTION_PTR; X++; Y--; if ( Y ) goto label_A306; MIRROR.DIRECTION = PRINCE.DIRECTION xor #FF; return; label_A319: $0072 = #89; $0073 = #A3; if ( !$0402 ) goto label_A379; label_A326: if ( !$0401 ) goto label_A379; $404++; if ( $72[Y] == #FF ) goto label_A37A; if ( $0404 ) goto label_A347; $0404 = #00; $0403 += 2; label_A347: Y++; A = $72[Y]; Y = #0E; sub_CAFD(); if ( MIRROR.POSE_INDEX != #6D ) goto label_A379; $0054 = $06F0 = #00; $04B1 = #03; sub_DB23(); A = #27; sub_F203(); #0610[X] = #02; A = #20; sub_F203(); #0610[X] = #02; label_A379: return; label_A37A: $060E = $061C = $0401 = #00; return; A386: .data[XX:YY],1C:01 FF // XX:time, YY:action, FF:EOF A389: .data[XX:YY],15:01 06:0D 02:02 03:32 0C:4E 02:05 17:01 FF label_A398: if ( level == #05 && !$610 ) goto label_A3A7; if ( PRINCE.X.LOW <= #10 ) goto label_A3A7; goto label_A3D1; label_A3A7: $0054 = #00; $04B1 = #0C; if ( !sub_DB18() ) goto label_A3D1; $0072 = #D2; $0073 = #A3; sub_A326(); if ( MIRROR.POSE_INDEX != #7C ) goto label_A3D1; $06FC = #00; $06FB = #0B; label_A3D1: return; A3D2: .data[XX:YY]: 04:02 19:2A F0:02 F0:02 F0:02 FF } char sub_F203() { $0017 = A; switch_bank(#02); sub_B298(); $04BF = Y; switch_bank($06D1); Y = $04BF; return; } char sub_B298() { X=#00; label_B29A: // aka sub_B29A Y=#00; if ( #060E[X] != #FF ) goto label_B2A4; Y++; label_B2A4: if ( #060E[X] & #7F == $0017 ) goto label_B2BC; if ( #060F[X] != #FF ) goto label_B2B2; Y++; label_B2B2: if ( Y == #02 ) goto label_B2BF; sub_F215(); goto label_B29A; label_B2BC: Y = #01; return; label_B2BF: Y = #00; return; } char sub_8730() { if ( A == #0616[Y] ) goto label_874B; // $0616+Y - address of MIRROR.ACTION_INDEX $0616[Y] = A; X = A << 1; #0613[Y] = #95F2[X]; // set MIRROR.ACTION_PTR to new value ($0613 + Y - address of ACTION_PTR in MIRROR struct) #0614[Y] = #95F3[X]; #0618[Y] = #FF; // set EOF marker label_874B: return; }

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

एक पैच बनाओ

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

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

व्यापक चक्र

जैसा कि हम याद करते हैं, मैपर # 02 में दो अलग-अलग प्रकार के मानचित्रण हैं। उनमें से एक - UNROM, - में 8 PRG-ROM बैंक शामिल हैं, और दूसरा - UOROM, - 16. यदि आप ROM फ़ाइल में एक और 8x16 kB डालें, तो मैपर गेम को नुकसान पहुंचाए बिना UOROM में बदल जाएगा। हालाँकि, सम्मिलित करें, ताकि अंतिम बैंक अंतिम रहे, और पहले 7 शुरुआत में रहें।

हम हेक्साडेसिमल संपादक में चढ़ते हैं, # 08 से # 10 तक हेडर (पांचवें बाइट, ऑफसेट 0x04) में बैंकों की संख्या बदलते हैं, फिर ऑफसेट 0x3C010 पर शुरू होने वाले 8x16 kB फ़ाइल में शून्य डालें। ROM फ़ाइल का आकार बदल जाएगा और 262 160 बाइट्स के बराबर हो जाएगा। एमुलेटर में परिणामस्वरूप ROM चलाएं ... यह काम करता है!
यदि हम हार्डवेयर में इस प्रक्रिया को करते हैं, तो हमें मैपर कंट्रोलर को बदलना होगा, और बढ़ी हुई ROM मेमोरी को डालना होगा - 32x8 kB, और हमें एक वर्किंग गेम भी मिलेगा।

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

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

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

 ;; ... $CC3B:20 00 CB JSR $CB00 $CC3E:20 12 9F JSR $9F12 $CC41:20 DD A3 JSR $A3DD $CC44:4C 1A CC JMP $CC1A

प्रक्रिया $ 9F12, $ A3DD को छुआ नहीं जाना चाहिए, क्योंकि वे दूसरे बैंक में हैं, जिसके स्थान पर हमारा होना चाहिए। उन्हें वहां स्थानांतरित करना भी असंभव है, क्योंकि वे बैंक की बाकी सामग्री के साथ खींच लेंगे। हालाँकि, आप नई प्रक्रिया के पते में $ CB00 के पते को बदल सकते हैं, जिसमें हमारा बैंक # 07 शामिल होगा, हमारे कोड को कॉल करेगा, फिर मूल प्रक्रिया $ CB00 को कॉल करेगा और नियंत्रण वापस लूप में लौटाएगा। कोड कुछ इस प्रकार है:

 LDA #07 JSR $F2D3 ;;   #07 JSR $8000 ;;   ,      JMP $CB00 ;;    $CB00, ;;    RTS

12 बाइट्स (प्रति निर्देश 3 बाइट्स)। थोड़ा, लेकिन उन्हें कहीं भी सम्मिलित करने की आवश्यकता है, लेकिन वैसे भी कोई जगह नहीं है। अंतिम बैंक में मौजूदा कोड को संशोधित करके थोड़ी सी जगह जीती जा सकती है। यह कुछ लंबी प्रक्रिया लेने के लिए पर्याप्त है जो बैंकों से डेटा का उपयोग नहीं करता है # 00 से # 06, जो इन बैंकों का उपयोग करने वाली प्रक्रियाओं को भी नहीं कहता है, और जो उन प्रक्रियाओं से कहा जाता है जो इन बैंकों का उपयोग नहीं करते हैं। हम इसे ढूंढने के बाद, हम इसे एक नए बैंक में स्थानांतरित करने में सक्षम होंगे, हमारे कोड को इसके स्थान पर रख देंगे, और हमारे कोड के सामने हम पीड़ित के कॉल को नए बैंक से रख देंगे।

कब तक, संक्षेप में, ऐसी प्रक्रिया पाई गई:

 $C111:AD C6 06 LDA $06C6 = #$00 $C114:C9 06 CMP #$06 $C116:B0 20 BCS $C138 $C118:AD D7 06 LDA $06D7 = #$04 $C11B:D0 1B BNE $C138 $C11D:8D 30 07 STA $0730 = #$00 $C120:85 54 STA $0054 = #$01 $C122:8D F0 06 STA $06F0 = #$00 $C125:AD 17 06 LDA $0617 = #$0C $C128:C9 11 CMP #$11 $C12A:90 0D BCC $C139 $C12C:C9 2B CMP #$2B $C12E:B0 09 BCS $C139 $C130:C9 1A CMP #$1A $C132:90 04 BCC $C138 $C134:C9 26 CMP #$26 $C136:90 01 BCC $C139 $C138:60 RTS

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

 $C111:20 17 C1 JSR $C117 ;;     $C114:4C 90 BF JMP $BF90 ;;     (     $BF90) ;;    RTS      ;; ========     ========== $C117:A9 07 LDA #$07 $C119:4C D3 F2 JMP $F2D3 ;; ========      ========== ;;   ,    $C11C:20 17 C1 JSR $C117 ;;   $C11F:20 10 B0 JSR $B010 ;;   .    - $B010. $C122:4C 00 CB JMP $CB00 ;;   $CB00,       $C125:00 BRK ;; ... $C138:00 BRK

न केवल हमने सफलतापूर्वक अपने कोड को कॉल किया है, हमारे पास अभी भी $ C125 से $ C138 तक बहुत सारे स्थान हैं, जिनका हम किसी और तरह से उपयोग कर सकते हैं: आखिरकार, हमारे पास अभी भी 7 (!) मुक्त बैंक हैं, और साथ हैं उन्हें अंतिम बैंक से काम करने की आवश्यकता होगी (यदि हम भविष्य में उनका उपयोग करेंगे)। मैंने $ B010 (लगभग बैंक के मध्य) में नए कोड का पता पोस्ट किया है, क्योंकि हमें अपने बैंक में स्तरों और कमरों की एक प्रति, और कुछ अन्य डेटा पोस्ट करने होंगे। लेकिन इसके बारे में अधिक नीचे।

हम प्रक्रिया को स्वयं संशोधित करते हैं, क्योंकि इसमें $ C139 के पते पर कूदता है, जो इसकी सीमाओं से परे है:

 $BF90:AD C6 06 LDA $06C6 = #$00 ;; ============ CUT ============ $BFAA:90 0D BCC $BFB9 $BFAC:C9 2B CMP #$2B $BFAE:B0 09 BCS $BFB9 $BFB0:C9 1A CMP #$1A $BFB2:90 04 BCC $BFB8 $BFB4:C9 26 CMP #$26 $BFB6:90 01 BCC $BFB9 $BFB8:60 RTS $BFB9:4C 39 C1 JMP $C139

वह सब है! एक बार जो पता $ C139 के लिए चला गया था अब वह $ BFB9 के पते पर जाता है, जिससे JMP निर्देश आपको $ C139 पर कूदने के लिए मजबूर करता है, जैसे कि हमने कहीं भी कोड को स्थानांतरित नहीं किया था।
मुख्य लूप का शरीर अब निम्न में बदला जा सकता है:

 ;; ... $CC3B:20 00 CB JSR $C11 $CC3E:20 12 9F JSR $9F12 $CC41:20 DD A3 JSR $A3DD $CC44:4C 1A CC JMP $CC1A

हम $ B010 पर कुछ डमी जैसे "RTS" रख सकते हैं और एमुलेटर में गेम शुरू कर सकते हैं। सब कुछ जैसा था - वैसा ही बना हुआ है।

हम "प्रतिबिंब" के लिए अपना "ड्राइव" लिखते हैं

यह केवल कमरे में प्रतिबिंब की उपस्थिति के लिए अपने स्वयं के एल्गोरिथ्म को विकसित करने के लिए बनी हुई है।
मैंने निम्नलिखित डेटा संरचना विकसित की है:

कमरे में प्रवेश करने पर, स्तर संख्या से हम पॉइंटर को पॉइंटर्स (लेवल्स पीटीएस) के पहले एरे में निकालते हैं, यदि यह शून्य नहीं है, तो दूसरे एरे (रूम पीटीआरएस) पर जाएं।
यदि कक्ष संख्या द्वारा निकाला गया सूचक शून्य भी नहीं है, तो प्रतिबिंब संरचना को पढ़ने के लिए आगे बढ़ें।
प्रतिबिंब संरचना इस प्रकार है:

एक संरचना जो चरित्र की प्रारंभिक स्थिति (संरचना वर्ण) का वर्णन करती है;
जोड़े "समय": "कार्रवाई", जो वर्णन करते हैं कि चरित्र क्या करेगा और किस समय अंतराल में करेगा;
अंतिम मार्कर #FF।

कोड की अधिकता के साथ पाठक को बोर नहीं करने के लिए, मैं इसे यहां उद्धृत नहीं करूंगा। वह लेख के अंत में होगा।

हम घटनाओं पर प्रतिक्रिया देते हैं

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

0500 डॉलर के पते से शुरू, हमारी स्मृति में हमारे पास डेटा है जो कमरों में कुछ परिवर्तन निर्धारित करते हैं। उदाहरण के लिए, यदि कोई पात्र बोतल से पोशन पीता है, तो बोतल वहां नहीं दिखाई देगी। या, यदि प्लेट गिरती है, तो इस सरणी में दोनों को संग्रहीत किया जाएगा जो अब अपनी जगह में एक छेद है, और उस जगह में जहां यह गिर गया - इसके टुकड़े। वही खुले और बंद ग्रिल के लिए जाता है। इस तरह की प्रत्येक घटना दो बिट्स में एन्कोडेड है। हमारे पास कमरे में 30 ब्लॉक हैं, 10 ब्लॉकों की प्रत्येक पंक्ति के लिए 3 बाइट्स (1 बाइट में 4 ब्लॉक फिट हैं, और तीसरे बाइट में शेष 4 बिट अप्रयुक्त हैं), प्रति कमरे में 9 बाइट्स हैं। इस प्रकार, 9 * 24 = 216 बाइट स्तर तक जाता है।

जैसे ही कोई कार्रवाई हुई है, इस सरणी में बिट्स की जोड़ी एक विशिष्ट मान पर सेट है। 3 संभावित संयोजन हैं (00 - इसका मतलब है कि कुछ भी नहीं हुआ), लेकिन कई घटनाएं हैं: ग्रेट खोला, ग्रिड बंद, बोतल से पिया, प्लेट गायब थी (गिरा), एक गिरी हुई प्लेट के टुकड़े; तदनुसार, घटनाएं ओवरलैप होती हैं। उदाहरण के लिए, यदि हम एक बोतल डालते हैं और उसके ऊपर एक गिरती हुई प्लेट लटकाते हैं, तो उसके गिरने के बाद हम या तो बोतल को छोड़ देंगे या फिर हमें प्लेट के टुकड़े नहीं दिखेंगे।

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

हम बटन दबाने के लिए मजबूर करते हैं

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

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

परिणाम स्पष्ट है:

फिन

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

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

पुनश्च

लेकिन यह अंत नहीं है। अंत के बाद, एक उपसंहार निम्नानुसार है: मैं संपादक के साथ समाप्त हुआ, लेकिन एक और अनसुलझे सवाल था जिसे मैं पार्स करना चाहूंगा। तो आगे उपसंहार है। कालकोठरी। "

मैं एक लिंक संलग्न करता हूं जहां आप संपादक के साथ संग्रह डाउनलोड कर सकते हैं, खेल पर एक छोटा दस्तावेज और पैच का स्रोत कोड।

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