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

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

त्याग

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

हम हेक्स संपादक खोलते हैं

डेटा के बिट्स के बीच कूदते हुए, मैंने पाया कि ROM फ़ाइल में ऑफसेट 0x18010 से शुरू होने पर, जब डेटा बदलता है, तो पहला कमरा ब्लॉक द्वारा ब्लॉक को बदलना शुरू कर देता है। लेकिन सबसे पहले, डेटा को देखें:
E0 E0 E0 01 21 01 21 01 14 14 13 13 21 03 00 14 14 14 14 14 14 14 14 14 0E 03 0B 21 01 14 ...
हम कह सकते हैं कि ये डेटा पूरी तरह से उस चीज़ के अंतर्गत आते हैं जो हमने पहले ग्रहण किया था। आप बाइट्स को दोहराने की काफी सामंजस्यपूर्ण पंक्तियों को देख सकते हैं (अर्थात, स्पष्ट रूप से एक कोड नहीं है) और वे, आंख से, किसी भी एन्क्रिप्टेड डेटा की तरह नहीं दिखते हैं। आइए पहले E0 को E1 में सावधानी से बदलने की कोशिश करें:

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

चारों ओर देख रहे हैं

चूंकि एक कमरे में एक ब्लॉक के लिए एक बाइट जिम्मेदार है, यह समझना अच्छा होगा कि एक निश्चित बाइट मान किस प्रकार के ब्लॉक के लिए जिम्मेदार है। खोज के दौरान, यह पता चला है कि 32 अलग-अलग ब्लॉक हैं, जिनमें से कुछ ग्राफिक कचरा खींचते हैं, और कुछ पूरी तरह से खेल को बर्बाद करते हैं। चूंकि ब्लॉक के 32 टुकड़े हैं, इसका मतलब है कि मूल्य के पहले 5 बिट्स ब्लॉक के प्रकार के लिए जिम्मेदार हैं। एक बाइट में शेष तीन बिट्स को बदलते हुए, हमें पता चलता है कि वे ब्लॉक की विशेषता के लिए जिम्मेदार हैं। उदाहरण के लिए, मान # 04 एक बंद ग्रिड है, और # 24 एक खुला ग्रिड है।
और अंत में, यदि हम इस 30-बाइट ब्लॉक के बाहर बाइट्स के माध्यम से सॉर्ट करते हैं, तो सुनिश्चित करें कि अन्य कमरे भी बदलते हैं। यहां, हालांकि, कमरों का क्रम किसी भी तरह अराजक है। वही अराजक क्रम तब था जब हमने पहले एक और डेटा ब्लॉक में इकाई को बदल दिया था और राजकुमार अब एक कमरे में, फिर दूसरे में दिखाई दिया। यह सच है, हम फिर भी असफल रहे।

आइए उस ब्लॉक पर करीब से नज़र डालें। हमें याद है कि उस ब्लॉक की ऑफसेट 0x18340 है और उस पर जाएं। हम एक एकल के बजाय एक ड्यूस लगाते हैं और राजकुमार दूसरे कमरे में कूदता है। आइए पिछले ब्लॉक में डेटा को संपादित करके इस कमरे को खोजने का प्रयास करें। खोज करने पर, हमें पता चलता है कि ये पहले कमरे के लिए जिम्मेदार 30-बाइट ब्लॉक के बाद अगले 30 बाइट्स हैं। इसलिए, वह इकाई कक्ष संख्या है। और कमरा संख्या 30-बाइट ब्लॉक की संख्या है। ठीक है, इसका मतलब है कि हमारे कमरे गिने जाते हैं, और वे एक से गिने जाते हैं।

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

फिलहाल, हम जानते हैं कि डेटा का एक अनिर्दिष्ट सरणी है जहाँ से कमरे बनाए जाते हैं। प्रत्येक कमरे को आकार में 30 बाइट्स के ब्लॉक द्वारा वर्णित किया गया है। कमरों के बाद अनिश्चित आकार के साथ एक निश्चित डेटा संरचना होती है। हम इसे स्तर का "शीर्षक" कहेंगे। और बाद में ... वास्तव में, आप कैसे जानते हैं कि आगे क्या है? हम जो पहले से जानते हैं, उसे करने दें।

हम कमरों को सुसज्जित करते हैं

आइए गणना करने की कोशिश करें कि हम शुरुआत और "हेडर" के बीच कितने कमरे फिट करते हैं, यह देखते हुए कि एक कमरा इस सरणी में 30 बाइट्स है:
0x182E9 - 0x18010 + 1 = 0x2DA = 730 ।
30 में विभाजित नहीं है। मृत अंत? कोई फर्क नहीं पड़ता कि कैसे। आइए कमरे के नंबरों के साथ एक स्तर आरेख बनाने की कोशिश करें। हम अभी के लिए ऐसा कर सकते हैं केवल राजकुमार को "हेडर" के पहले बाइट को बदलकर। इसे कमरे से कमरे तक क्रमिक रूप से ले जाने पर, हम पाते हैं कि यह या तो दूसरे कमरे में समाप्त होता है, या खेल बिल्कुल भी शुरू नहीं होता है। हम उन संख्याओं को शामिल करते हैं जो विफल होती हैं, और शेष संख्याओं को खेल में उनकी स्थिति के अनुसार रखते हैं:

यह कहना मुश्किल है कि डेवलपर्स द्वारा क्या निर्देशित किया गया था, लेकिन यदि आप संख्याओं पर भरोसा नहीं करते हैं, तो योजना काफी प्रशंसनीय है।

आइए इन कमरों की तुलना करने की कोशिश करें कि हमारे पास क्या है। 1 से 12 तक हमारे पास आरेख पर कमरे हैं, लेकिन 13 (और फिर 18 और 24) गायब हैं। हम इसके ऑफसेट पर विचार करते हैं: 0x18010 + 12( )*30( ) = 0x18010 + 0x168 = 0x18178 ।
हम पास करते हैं और देखते हैं:
FF 14 14 14 E1 03...
#FF? और फिर आगे क्या आता है? हम 14 कमरे में जाते हैं और देखते हैं कि ऊपरी बाएं कोने में 3 "कंक्रीट" ब्लॉक हैं, फिर एक मंच, और फिर एक स्तंभ है। यह बहुत संभावना है कि चौदहवें कमरे के पहले तीन "कंक्रीट" ब्लॉकों को संख्या # 14 द्वारा वर्णित किया गया है, मंच # E1 है, और स्तंभ # 03 है। इसलिए, # एफएफ के लिए पहले से ही कमरा 14 का विवरण है, और कमरा 13 खुद ही एक बाइट - # एफएफ में कम हो गया था। ऐसा लगता है कि # एफएफ किसी प्रकार का मार्कर है, जिसका अर्थ है कि कमरा अनुपस्थित है। 18 और 24 कमरों के लिए स्थिति समान है।
लेकिन संख्या 25 और ऊपर, जाहिरा तौर पर, अब नहीं हैं, क्योंकि # एफएफ मार्कर के बाद, जो हमें बताता है कि कमरा नंबर 24 नहीं है, डेटा का एक सेट है जो पिछले वाले के समान नहीं है:
05 00 00 02 06 03 01 00 02 09 00 00...
बेशक, आप इन नंबरों के साथ खेल सकते हैं, लेकिन हमारी योजना को देखें।

• पहला कमरा कमरा 05 और 02 से घिरा हुआ है;
• दूसरा कमरा 06, 01 और 03 कमरों से घिरा हुआ है;
• तीसरा कमरा 02 और 09 के कमरे से घिरा हुआ है;
• ...

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

• पहले कमरे के बाईं ओर पांचवां है;
• दूसरे के बाईं ओर छठा है;
• तीसरे के बाईं ओर दूसरा है;

यह देखा जा सकता है कि संख्या 5, 6 और 2 4 स्थानों में से एक में हैं। तो, एक कमरे के वातावरण को चार बाइट्स की संरचना द्वारा वर्णित किया गया है, और उनमें से पहला बाईं तरफ का कमरा नंबर है। स्तर के नक्शे के आधार पर, शेष तीन बाइट्स सही, ऊपर और नीचे के कमरे का वर्णन करते हैं। इसके अलावा, अगर कोई जगह नहीं है, तो 0. उपयुक्त स्थान पर होगा। इन संरचनाओं की संख्या ठीक 24 है, जिसके बाद स्तर का "शीर्षक" शुरू होता है। यदि ऐसा है, तो हम अधिकतम 24 कमरे बना सकते हैं (फिर, कोड का अध्ययन करके, हम इसे देखेंगे)।

गार्ड को बुलाओ!

पिछली बार, हमने कुछ डेटा संरचनाओं को पॉइंटर्स का एक सरणी पाया, जिसे हमने "हेडर" कहा। इसके अलावा, ऐरे को पढ़ते समय, दोहरे स्तर अनुक्रम संख्या को एक सूचकांक के रूप में उपयोग किया जाता था। तो इस सरणी में अगले दो बाइट्स उसी संरचना के लिए एक संकेतक है, लेकिन दूसरे स्तर पर। हम इसका भी अध्ययन करेंगे:
संकेत की सीमा: D9 82 61 86 91 89 ...

• पहला स्तर: D9 82 -> $82D9 -> फ़ाइल में ऑफसेट 0x182E9 ;
• दूसरा स्तर: 61 86 -> $8661 -> फ़ाइल में ऑफसेट 0x18671 ;
• ...

हम इस तरह के डेटा से मिले हैं:
05 0D FF 1E 9E ... (मजाकिया, यहां, पहले तीन बाइट्स के बाद, 0x0E में समाप्त होने वाली संख्या फिर से जाएगी)

यहां पहला नंबर # 05 है, इसलिए राजकुमार सीरियल नंबर 5 के साथ कमरे में शुरू होता है। लेकिन अगले दो बाइट्स अब शून्य नहीं हैं।
यदि आप उनके साथ खेलते हैं, तो हमें पता चलेगा कि # 0D कमरे में राजकुमार की स्थिति है। संभावित पदों की कुल संख्या 10x3 = 30 है, जहां 10 कमरे की चौड़ाई है, जिसका मतलब है कि # 0D = 13 3x1 स्थिति है, अर्थात यह बाईं ओर चौथे ब्लॉक के स्थान पर होगा और शीर्ष पर दूसरा होगा। #FF मान के साथ अगला बाइट इसकी दिशा है: यदि #FF, तो यह चारों ओर मुड़ जाएगा और बाईं ओर देखेगा, यदि #FF नहीं है, तो यह दाईं ओर रहेगा। केवल अजीब बात यह है कि पहले स्तर में वह अपनी स्थिति नहीं बदलता है। लेकिन हम बाद में पता लगाएंगे।

आइए देखें कि पहले तीन बाइट्स क्या हैं।
जैसा कि हम याद करते हैं, पहले स्तर में, पहली बाइट को बदलते समय, कमरे में एक गार्ड दिखाई देता था। तो ये नंबर कमरे में एक गार्ड की उपस्थिति के लिए किसी तरह जिम्मेदार हैं।

आइए पहले स्तर पर वापस जाएं और चौथे क्षेत्र में # 02 (पिछली बार के रूप में) लिखें। गार्ड राजकुमार के बहुत करीब दिखाई दिया। हमने # 03 डाला। दिखाई दिया, लेकिन पहले से ही बहुत दूर। # 1D तक के मूल्यों के माध्यम से जाने पर, हम यह सुनिश्चित करते हैं कि यह बाइट गार्ड की स्थिति के लिए जिम्मेदार है। लेकिन जब हम 0x1E सेट करते हैं तो यह गायब हो जाता है। लेकिन दशमलव प्रतिनिधित्व में 0x1E = 30, जिसका अर्थ है कि यदि हम स्थिति की सीमा मूल्य निर्धारित करते हैं, तो इसका मतलब होगा कि कमरे में कोई गार्ड नहीं है। जाहिर है, शेष बाइट अन्य कमरों में गार्ड के लिए जिम्मेदार हैं। यही है, अगले बाइट दूसरे कमरे में गार्ड की उपस्थिति के लिए जिम्मेदार है, फिर तीसरे में और इसी तरह। हालांकि, यह एक साधारण जांच से पुष्टि की जाती है। यह जाँचने से भी पता चलता है कि मूल्य के केवल पहले 5 बिट्स गार्ड की स्थिति के लिए जिम्मेदार हैं, शेष 3 बिट्स का उपयोग नहीं किया जाता है, चाहे हम उन्हें कैसे भी मोड़ दें।

यह सब एक साथ लाना: बिल्डर्स, आर्किटेक्ट्स, और अभिभावक

कुल में, हमारे पास निम्नलिखित डेटा संरचनाएँ हैं:

• "ईंटें" जिसमें से कमरे बने हैं। गैर-निश्चित मूल्य की संरचना;
• कमरों का लेआउट। लंबाई में निश्चित (4x24 बाइट्स);
• एक छोटी संरचना बताती है कि राजकुमार कैसे और कहाँ दिखाई देगा (3 बाइट्स) - स्तर का "शीर्षक";
• कमरों में गार्डों के स्थान का वर्णन करने वाली संरचना (24 बाइट्स)।

लेकिन यह असुविधाजनक है: पॉइंटर जो हमारे पास है (बिंदुओं के सरणी से) हमें "हेडिंग" की ओर ले जाता है, जिसका अर्थ है कि हमें स्तर की शुरुआत की भरपाई करनी होगी। आइए डिबगर पर एक नज़र डालें और देखें कि यह कैसे मायने रखता है।
हम जानते हैं कि शुरुआत ऑफसेट 0x18010 पर स्थित है, जिसका अर्थ है कि यह बिल्कुल 8000 डॉलर के पते पर मेमोरी में होगा। लेकिन हमारे पास कई बैंक हैं, इसलिए हम केवल उसी चीज़ को ट्रैक करेंगे जो हमें चाहिए। हमने उसकी संख्या नहीं गिना, हम केवल उस डिबगर को बताते हैं जिसे हम $ 8000 में पढ़ने में रुचि रखते हैं, और पहली बाइट # E0 (पहले स्तर के पहले कमरे में पहला ब्लॉक) होनी चाहिए:


पहला पड़ाव हमें इस प्रक्रिया से रूबरू कराता है:

 $C0F6:20 C7 C0 JSR $C0C7 $C0F9:A5 52 LDA $0052 = #$00 $C0FB:18 CLC $C0FC:65 6D ADC $006D = #$00 $C0FE:85 0E STA $000E = #$00 $C100:A5 53 LDA $0053 = #$00 $C102:65 6E ADC $006E = #$80 $C104:85 0F STA $000F = #$80 $C106:8C 0B 04 STY $040B = #$03 $C109:A0 00 LDY #$00 $C10B:B1 0E LDA ($0E),Y @ $8000 = #$E0 ;; <<<<<  $C10D:AC 0B 04 LDY $040B = #$03 $C110:60 RTS 

कोशिकाओं में $ 0E: $ 0F हमारे पास $ 8000 का पता है। वहां उन्हें परिचित $ 6D: $ 6E कोशिकाओं से मिला, जिसमें $ 52 और $ 53 कोशिकाओं के मूल्यों को जोड़ा गया था। सेल $ 52, $ 53 अब शून्य हैं, इसलिए हम रुचि रखते हैं कि कैसे संख्या # 00 और # 80 $ 6D में मिली: $ 6E।
प्रक्रिया की शुरुआत में, हम $ C0C7 पर एक अन्य प्रक्रिया के लिए कॉल देखते हैं। हम वहाँ पहुँचते हैं:

 $C0C7:20 D5 C0 JSR $C0D5 $C0CA:BD 3A EB LDA $EB3A,X @ $EB3A = #$00 $C0CD:85 6D STA $006D = #$00 $C0CF:BD 3B EB LDA $EB3B,X @ $EB3B = #$80 $C0D2:85 6E STA $006E = #$80 $C0D4:60 RTS 

शुरुआत में, हम परिचित प्रक्रिया को कॉल करते हैं sub_C0D5 (जो रजिस्टर X में हमें डबल लेवल की संख्या क्रमांक में देता है), और फिर अंतिम बैंक से पढ़ रहा है। हम अपने नियम के अनुसार विचार करते हैं: $EB3A+0x10010=0x1EB4A

हम देखते हैं:
00 80 31 83 9B 86 C1 89 ...
वास्तव में। हमारे "ईंटों" को इंगित करता है। यदि आप इस कोड के आसपास के क्षेत्र में चढ़ते हैं, तो हम तीन समान प्रक्रियाओं को देखेंगे - वे एक के बाद एक लगभग चलते हैं। हमने उनमें से दो को देखा, और तीसरा (0x1EB82) सरणी को संदर्भित करता है, जो कमरों के लेआउट की ओर जाता है।

लगता है वे सब इकट्ठे हो गए? कोई फर्क नहीं पड़ता कि कैसे।

दरवाजा खोलो

सिद्धांत रूप में, हम नींव से और छत के साथ एक स्तर बना सकते हैं, लेकिन ग्रिल के बारे में क्या? उन्हें प्रबंधित किया जाना चाहिए। आइए उनके व्यवहार का अध्ययन करने का प्रयास करें।

हम राजकुमार को कमरा नंबर 5 में रखते हैं, क्योंकि एक साथ दो लट्टे और तीन बटन हैं। उनमें से एक भट्ठी को बंद करता है, और दूसरा दो को खोलता है। फिर मुझे एक मूर्खता मिली: मैं एक डेवलपर के रूप में ग्रिड के साथ बटन कैसे जोड़ सकता हूं?


शुरू करने के लिए, अब हम क्या कर सकते हैं बटन या सलाखों को स्थानांतरित करें और प्रभाव देखें।
आगे बढ़ने के बाद पहली बार खुलने से रुकना। चलते समय बटन ने भी काम करना बंद कर दिया। लेकिन अगर आप दो बटन ("उच्च" और "कम") स्वैप करते हैं, तो "कम" बटन (छवि में यह "उच्च" के बाईं ओर दो स्थिति है जिस पर राजकुमार खड़ा है - यह दिखाई नहीं देता है) खुलने लगा, और "उच्च" "बंद। इसलिए, बटन और बार के स्थान (पहले से, हम शून्य से और एक से कमरे) की गणना करेंगे, विशिष्ट रूप से जुड़े हुए हैं, लेकिन कैसे? मैंने इन पदों को एक कॉलम में लिखा और यह प्लेट प्राप्त की:
Button Room - Button Position : Door Room - Door Position
05 - 02 : 05 - 09 - "कम" बटन दूसरी ग्रिल को बंद कर देता है।
05 - 04 : 05 - 05 + 05 - 09 - पहला "उच्च" बटन दोनों grilles खोलता है।
05 - 08 : 05 - 09 - दूसरा "उच्च" बटन केवल दूसरा जंगला खोलता है।

इस तालिका पर विचार करते हुए, मैं किसी तरह एचईएक्स संपादक में स्वचालित रूप से शामिल हो गया और स्तर के "शीर्षक" पर फिर से देखने का फैसला किया। मेरी उम्मीदों के विपरीत, सरणी के अंत के बाद, जिसने गार्ड के कमरे रखे थे, यह दूसरा स्तर नहीं था जो शुरू हुआ, लेकिन कुछ अन्य डेटा की एक सरणी। उनके तुरंत बाद दूसरा स्तर शुरू हुआ।
05 02 01 05 09 05 04 00 05 09 05 04 00 05 05 05 08 00 05 09 ...
बाइट्स ने तालिका में लगभग मेरी प्रविष्टियों को लगभग दोहराया, केवल एक बृहदान्त्र के बजाय या तो 00 या 01 थे। यह मानते हुए कि मेरे पास "रिकॉर्ड के पहले" करीब "शब्द" है और दूसरों के सामने "खुला" है, यह देखना आसान है कि 00 कहते हैं कि इस गुच्छा में जाली खुल जाएगी, और 01 बंद हो जाएगा। सत्यापन से पता चला कि ऐसा है। अब हमने दरवाजे खोलने के तंत्र के लिए यांत्रिकी को भी जिम्मेदार पाया है।

संपादक

खैर, क्या संपादक लगभग तैयार है? यह तीन ऑफ़सेट लेने के लिए पर्याप्त है, उन्हें पॉइंटर्स से तीन संरचनाओं (कमरे, स्तर की ज्यामिति और "हेडिंग") और संपादक में प्रदर्शित करने के लिए निर्धारित किया जाता है। कोई फर्क नहीं पड़ता कि कैसे।

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

सब कुछ ठीक है, लेकिन 10 के स्तर पर एल्गोरिथ्म एक अपवाद फेंकता है: वे कहते हैं कि कमरा नंबर 1 कमरा नंबर 3 को संदर्भित करता है, और कमरा नंबर 3, बदले में, 00 को संदर्भित करता है, जिसका अर्थ है कि इसके ऊपर कोई कमरे नहीं हैं। खेल में, हमें कमरा नंबर 1 ("स्तर 10 इसके साथ शुरू होता है") "के तहत" नहीं मिल सकता है।
मोटे तौर पर स्केच किए गए कमरा नंबर 3 में, यह स्पष्ट हो गया कि यह बहुत शुरुआती कमरा है जिसके साथ खेल शुरू होता है। इसमें, हमें दाईं ओर जाने और खेल को फिर से शुरू करने, या बाएं करने की पेशकश की जाती है, जहां हम पासवर्ड टाइप करते हैं और उचित स्तर पर पहुंचते हैं।
कमरा नंबर 3 में एक रूममेट है - कमरा नंबर 12। और फिर भी, हाँ, इसमें सिर्फ एक बोतल और एक निकास द्वार है।

इस प्रकार, हमारे लिए संपादक के लिए इन कमरों को ध्यान में रखना, और एक स्तरीय मानचित्र बनाना पर्याप्त होगा।

nesprinced

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

मैंने लंबे समय तक संपादक के नाम के बारे में नहीं सोचा था: प्रिंसेड है, जो डॉस संस्करण के लिए है, और हमारे पास एनईएसप्रिनएड है, जो एनईएस संस्करण के लिए है।
इस बिंदु पर, मैंने सोचा कि अब शेल लिखना पर्याप्त है और संपादक तैयार है। मैं तब कितना गलत था ... और चौथे अध्याय में, जिसे "वह चलाता है" कहा जाता है! या एक कोठरी में कंकाल, "हम इस बारे में आश्वस्त होंगे।