एक कंसोल एमुलेटर बनाएं

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







इस लेख में, मैं 70 के दशक से CHIP-8 गेमिंग प्लेटफॉर्म का एक सरल एमुलेटर बनाने के बारे में बात करना चाहूंगा। सबसे पहले, हम इतिहास पर स्पर्श करेंगे, और दूसरी बात, अपनी सादगी के कारण, यह मंच नौसिखिए प्रोग्रामर के लिए भी पूरी तरह कार्यात्मक एमुलेटर बनाना संभव बना देगा।

अंत

कोई फर्क नहीं पड़ता कि यह कितना अजीब हो सकता है, मैं अंत से शुरू करूँगा। यहां इस तरह का कार्यक्रम है

विकल्प बायनेरी ; हम एक बाइनरी फ़ाइल चाहते हैं, एचपी 48 एक नहीं।

डिजाइन बंद ; और हम कुछ के रूप में ऑटो संरेखण नहीं चाहते हैं

; डेटा शब्दों के बजाय बाइट्स से बना हो सकता है।



LD V0 , 0

LD V1,0



LOOP :

LD I , LEFT ; हम यादृच्छिक संख्या के रूप में, डिफ़ॉल्ट रूप से एक बाईं रेखा खींचते हैं

; है 0 या 1. यदि हम मानते हैं कि यह 1 होगा, तो हम रखते हैं

; बाईं रेखा खींचना। यदि यह 0 है, तो हम रजिस्टर बदलते हैं

; मुझे एक सही रेखा खींचनी है।



आरएनडी वी 2 , 1 ; V2 में लोड एक 0 ... 1 यादृच्छिक संख्या



एसई वी 2 , 1 ; यह 1 है? यदि हां, तो मैं अभी भी बाईं पंक्ति को संदर्भित करता हूं

; बिटमैप।



LD I , राइट ; यदि नहीं, तो हम इसे सही लाइन को संदर्भित करने के लिए बदल देते हैं

; बिटमैप।



DRW V0 , V1 , 4 ; और हम V0, V1 पर बिटमैप बनाते हैं।



ADD V0 , 4 ; अगला बिटमैप 4 पिक्सल सही है। इसलिए हम अपडेट करते हैं

; ऐसा करने के लिए V0।



एसई वी 0 , 64 ; यदि V0 == 64, हमने एक पूर्ण रेखा खींचना समाप्त कर दिया है, इसलिए हम

; कूद को LOOP पर छोड़ दें, क्योंकि हमें V1 को भी अपडेट करना है।



जेपी LOOP ; हमने पूरी लाइन नहीं खींची? तो हम जारी रखते हैं!



LD V0 , 0 ; प्रत्येक पंक्ति का पहला बिटमैप 0, V1 है।



ADD V1 , 4 ; हम V1 को अपडेट करते हैं। अगली पंक्ति 4 पिक्सेल डैन स्थित है।



एसई वी 1 , 32 ; क्या हमने सभी रेखाएँ खींच दी हैं? यदि हाँ, V1 == 32

जेपी LOOP ; नहीं? तो हम जारी रखते हैं!



फिन : जेपी फाइनल ; अनंत लूप ...



सही :; बाईं रेखा के 4 * 4 बिटमैप



DB $ 1 ……।

डब $ । 1 ......

डीबी $ .. 1 .....

DB $ ... 1 ....



वाम :; सही रेखा के 4 * 4 बिटमैप

; और हाँ, यह ऐसा है ...

डीबी $ .. 1 .....

डब $ । 1 ......

DB $ 1 ……।

DB $ ... 1 ....

38 बाइट्स पर कब्जा कर रहा है और संकलित रूप में इस तरह दिख रहा है





अंततः हमारे एमुलेटर में निष्पादित किया जाना चाहिए और लगभग निम्नलिखित चित्र प्रदर्शित करना चाहिए:







हम अंत के साथ कर रहे हैं, हम थोड़ा थकाऊ लेकिन आवश्यक सिद्धांत की ओर मुड़ते हैं।

आर्किटेक्चर

तो CHIP-8 गेमिंग प्लेटफॉर्म क्या है? अंग्रेजी बोलने वाले विस्तृत विकिपीडिया लेख पढ़ सकते हैं, लेकिन मैं अपने शब्दों में मुख्य बिंदुओं को फिर से बताने की कोशिश करूंगा।



CHIP-8 एक व्याख्यात्मक प्रोग्रामिंग भाषा है जो 70 के दशक में COSMAC VIP और टेल्मैक 1800 गेम कंसोल के लिए बनाई गई थी। CHIP-8 के लिए लिखे गए और संकलित प्रोग्राम वर्चुअल मशीनों में कंसोल पर स्वयं चलाए जाते हैं। खैर, आधुनिक सादृश्य द्वारा, यह जावा बाइटकोड का एक सा है। मैं आम तौर पर आपको एमुलेटर बनाने के समय पर भूल जाने की सलाह देता हूं कि यह एक व्याख्या की गई भाषा है, और मान लें कि हम एक लोहे के प्लेटफॉर्म का अनुकरण करते हैं - एक प्रोसेसर जिसके पास निर्देशों का सेट है। इसके अलावा, जब मैं कहता हूँ "उपसर्ग," मेरा मतलब CHIP-8 होगा।







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



स्मृति



उपसर्ग में 4Kb मुख्य मेमोरी (RAM) है। मेमोरी क्रमशः ऑफसेट 200h पर शुरू होती है और ऑफसेट FFFh पर क्रमशः समाप्त होती है। प्रोग्राम मेमोरी 200h पर क्यों शुरू होती है? सब कुछ बहुत सरल है - मूल कंसोल में मेमोरी के पहले 512 बाइट्स सिर्फ प्रोसेसर के मशीन कोड में सीएचआईपी -8 भाषा के दुभाषिया द्वारा कब्जा कर लिया जाता है, जिस पर उपसर्ग बनाया गया है।



रजिस्टरों



CHIP-8 में V0 ... VF नाम के साथ सोलह 8-बिट डेटा रजिस्टर हैं। VF रजिस्टर अतिरिक्त / घटाव संचालन के दौरान कैरी फ्लैग के लिए जिम्मेदार है। उपसर्ग में एक 16-बिट पता रजिस्टर I भी है।



अनेकता



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



टाइमर



उपसर्ग में दो 8-बिट टाइमर होते हैं, वे दोनों शून्य तक पहुंचने तक 60 हर्ट्ज की आवृत्ति पर कम हो जाते हैं।

विलंब टाइमर: इस टाइमर का उपयोग खेलों में विभिन्न देरी के लिए किया जाता है, इसके मूल्य को कमांडों का उपयोग करके पढ़ा / बदला जा सकता है।

ध्वनि टाइमर: जब टाइमर मूल्य गैर-शून्य होता है, तो एक बीप ध्वनि आउटपुट होता है।



इनपुट डिवाइस



16 कुंजी का उपयोग करके प्रवेश किया जाता है। मूल कंसोल में, कुंजी में 0h से Fh तक के कोड होते हैं। यदि हम कंप्यूटर पर अनुकरण करते हैं, तो कीबोर्ड के सही NumPad भाग का उपयोग करना सबसे सुविधाजनक है, वह नंबर जहां 0-9 और NumLock स्थित हैं। कुंजी '8', '4', '6' और '2' का उपयोग आमतौर पर स्थानांतरित करने के लिए किया जाता है, हालांकि हमेशा ऐसा नहीं होता है। यह खेल पर निर्भर करता है।



ग्राफिक्स और ध्वनि



हमारे कंसोल में, स्क्रीन रिज़ॉल्यूशन 64x32 पिक्सेल, एक रंग (मोनोक्रोम) है। आउटपुट स्प्राइट्स का उपयोग करके कार्यान्वित किया जाता है, जिसमें हमेशा 8 पिक्सेल की चौड़ाई होती है और इसकी लंबाई 1 से 15 पिक्सेल हो सकती है। यदि ड्राइंग के दौरान स्प्राइट को किसी अन्य स्प्राइट पर सुपरइम्पोज किया जाता है, तो ओवरले बिंदु पर रंग उल्टा होता है, और VF (कैरी फ्लैग) रजिस्टर 1 मान लेता है। अन्यथा, यह मान 0 लेता है।



जैसा कि ऊपर उल्लेख किया गया है, यदि ध्वनि टाइमर का मूल्य गैर-शून्य है, तो एक गंदा चीख़ती ध्वनि बजाई जाती है। मुझे लगता है कि हमें ध्वनि का बिल्कुल भी एहसास नहीं है, मैं इन बीप्स की तरह नहीं हूं।



आदेशों



हमारे प्रोसेसर (वास्तव में CHIP-8) में बिल्कुल 35 निर्देश हैं, प्रत्येक निर्देश में हमेशा दो बाइट्स की लंबाई होती है। यहां मैं आदेशों की तालिका को फिर से नहीं लिखूंगा, यह विकिपीडिया पर है । आप उदाहरण के लिए, वहां से कुछ उदाहरणों को पार्स कर सकते हैं:

00E0 स्क्रीन साफ़ करता है। - जब हम 00E0 कोड में मिलते हैं, तो स्क्रीन को साफ करें।

6XNN NX को VX सेट करता है। - VX रजिस्टर को NN पर सेट करें। उदाहरण के लिए, यदि आप 635A कमांड से मिले हैं, तो आपको V3 रजिस्टर में मान 5Ah लिखना होगा।

अभ्यास

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



यह स्पष्ट है कि एमुलेटर शुरू करते समय सबसे पहले हम अपनी वर्चुअल मशीन को इनिशियलाइज़ करते हैं। वह है, स्पष्ट मेमोरी, स्टैक, रजिस्टर और वीडियो मेमोरी। जैसा कि मैंने ऊपर लिखा है, जिस ऑफसेट पर हम अपना उत्सर्जित कार्यक्रम लोड करेंगे, वह 200 h है। इससे पहले, ऑफसेट 000h से 1FFh तक, मूल दुभाषिया स्थित होना चाहिए। इसमें, अन्य बातों के अलावा, एक छोटा फ़ॉन्ट है जो ऑफसेट 000h से शुरू होता है और 050h तक होता है और 80 बाइट्स लेता है। इसे मेरे एमुलेटर के सोर्स कोड में देखा जा सकता है। हां, मैं अपने फ्रांसीसी डेल्फी के लिए माफी मांगता हूं, लेकिन मैं इस पर कार्यक्रम करता हूं, मुझे दोष मत देना। सादगी के लिए, मैंने यह संरचना बनाई:

प्रदर्शन : ऐरे [ 0..64 * 32-1 ] बाइट ; // वीडियो मेमोरी

मेमोरी : बाइट का ऐरे [ 0..4095 ] ; // रैम मेमोरी

स्टैक : एरे [ 0..15 ] वर्ड का ; // ढेर

रजिस्टर : बाइट का [ 0..15 ] एरे ; // रजिस्टर

rI : शब्द = $ 200 ; // मैं रजिस्टर करता हूं

एसपी : बाइट = 0 ; // स्टैक काउंटर

पीसी : शब्द = $ 200 ; // मेम ऑफसेट काउंटर

delay_timer : बाइट = 255 ; // देरी टाइमर;

sound_timer : बाइट = 255 ; // साउंड टाइमर;

इसलिए, शुरुआत में हम सभी सरणियों को शून्य से भरते हैं, फिर जीरो से शुरू होने वाले मेमोरी एरे में फ़ॉन्ट (फ़ॉन्ट: सरणी [1..80]) को कॉपी करें और सभी मानों को इनिशियलाइज़ करें:

फिल्चर ( मेमोरी , 4096 , 0 ) ; // मुख्य मेमोरी को साफ़ करें

चाल ( फ़ॉन्ट , मेमोरी , 80 ) ; // ऑफ़सेट में फॉन्ट कॉपी करें 000h

फिल्चर ( स्टैक , 16 , 0 ) ; // स्टैक साफ़ करें

फिल्चर ( रजिस्टर , 16 , 0 ) ; // रजिस्टर को शून्य पर रीसेट करें



आरआई : = $ 200 ; // कार्यक्रम की शुरुआत में पता रजिस्टर I

पीसी : = $ 200 ; // सरणी ऑफसेट



एसपी : = 0 ; // स्टैक काउंटर

delay_timer : = 0 ; // टाइमर से शून्य तक

sound_timer : = 0 ;

अब सब कुछ तैयार किया गया है, आप 200h को मेमोरी में ऑफसेट किए गए प्रोग्राम को पढ़ सकते हैं और कोड्स की व्याख्या कर सकते हैं। यहां आपको थोड़ा याद रखना होगा कि बिट्स कौन हैं, और बाइट्स और शब्द (शब्द) से उन्हें कैसे निकालना है। सादगी के लिए, मैंने एक ExecuteOpcode (opcode: word) प्रक्रिया बनाई, जिसमें एक दो-बाइट opcode पारित, व्याख्या और निष्पादित किया जाता है। अर्थ समझने के लिए, आप विकिपीडिया से आदेशों की तालिका देख सकते हैं।

प्रक्रिया ExecuteOpcode ( opcode : शब्द ) ;

शुरू करना

मामला ( op_code और $ F000 ) 12 की // साइट opcode से पहले 4 बिट्स का चयन करें

$ 00 : प्रारंभ // opcode खरोंच से शुरू हुआ

केस op_code और $ 00FF का

// यह हमारा opcode 00E0 है - स्क्रीन को साफ़ करें

$ E0 : शुरू करें

// काम करो, अर्थात्, स्क्रीन को मूर्खतापूर्ण रूप से साफ़ करें

बाहर निकलने के;

अंत ;

// और यह 00EE है - प्रक्रिया से बाहर निकलें

$ EE : आरंभ करें

// स्टैक से पते को पुनर्स्थापित करें, इसे कूदें

बाहर निकलने के;

अंत ;

अंत ;

// और यहाँ जाओ अगर opcode खरोंच से शुरू हुआ, लेकिन न तो E0 और न ही EE समाप्त हुआ

// इसलिए, या तो अमान्य ओपकोड संदेश को पकड़ो या प्रदर्शित करो

बाहर निकलने के;

अंत ; // null opcode के लिए एंड चेक

$ 01 : शुरू // opcode के पहले चार बिट्स हैं 1 (opcode एक के साथ शुरू हुआ)

// यह JMP है, कूदो। हम वांछित पते पर जाते हैं

पीसी : = op_code और $ 0FFF;

बाहर निकलने के;

अंत ;

$ 02 : प्रारंभ // ओपकोड के पहले चार बिट्स 2 हैं (ओपकोड एक दो के साथ शुरू हुआ)

// सबरूटिन को कॉल करें।

// स्टैक पॉइंटर को बढ़ाएं

// स्टैक पर वर्तमान पते को धक्का दें

// और सबरूटीन पर प्रहार

अंत ;

//

// यह जारी रहता है जब तक कि ओपकोड 7 से शुरू नहीं होता है।

//



$ 08 : शुरू // opcode 8 पर शुरू हुआ। यहां आपको अंतिम 4 बिट्स देखने की जरूरत है

मामला op_code और $ 000F // पिछले 4 बिट्स opcode का

// mov vx, vy

$ 00 : शुरू करें

// मान VY को रजिस्टर VX में रखें

बाहर निकलने के;

अंत ;

// या vx, vy

$ 01 : शुरू करें

// VX = VX या VY

बाहर निकलने के;

अंत ;

//

// यह 0 ई पर जारी है

//



अंत ; // ओपकोड के अंतिम 4 बिट्स की जाँच का अंत

// यहां प्राप्त करें यदि अमान्य ओपकोड

बाहर निकलने के;

अंत ; // चेक का अंत यदि ओपकोड 8 से शुरू हुआ

और इसी तरह, मुझे लगता है कि यह विचार कम या ज्यादा स्पष्ट होना चाहिए। दुभाषिया लिखते समय, आप कुछ कमांड के लिए स्टब्स का उपयोग कर सकते हैं। अब, जब हम मूल प्रोसेसर निर्देशों को लागू करते हैं, तो यह स्क्रीन पर आउटपुट आकर्षित करने और इनपुट डिवाइस को लागू करने के लिए बना रहता है। स्क्रीन पर प्रदर्शित होने के लिए DXYN कमांड जिम्मेदार है। रजिस्टर में VX का समन्वय X है, रजिस्टर में VY का समन्वय Y है जिसमें से हमें स्प्राइट निकालना शुरू करना चाहिए। इस समय पता रजिस्टर I स्प्राइट की बिटमैप छवि को इंगित करता है। मैं ड्राइंग ग्राफिक्स के कार्यान्वयन को लागू नहीं करूंगा, मुझे लगता है कि इसमें कोई कठिनाई नहीं होनी चाहिए, खासकर जब से आप हमेशा इस पोस्ट के अंत में स्रोत में देख सकते हैं। तो कीबोर्ड है।

निष्कर्ष

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

मैं अपने कोड के लिए पहले से माफी चाहता हूं, मैंने इसे क्रम में नहीं रखा - मैंने इसे वैसे ही डाला। मुख्य दिलचस्प फ़ाइल hchip.pas है, यह सभी अनुकरण को लागू करती है।



एक अच्छा अंग्रेजी बोलने वाला फ़ोरम EmuTalk भी है, जिसमें चिप -8 का अनुकरण करने के लिए समर्पित एक धागा विशेष रूप से हाइलाइट किया गया है।



वह पृष्ठ जहाँ आप शायद इसके लिए सबसे अच्छे चिप 8 एमुलेटर और गेम डाउनलोड कर सकते हैं।



वैसे भी, Google "चिप -8" में अनुरोध पर आप अपनी जरूरत का हर सामान पा सकते हैं।



और क्या किया जा सकता है? आप सुपर चिप -8 निर्देशों और स्प्राइट्स का समर्थन करने के लिए हमारे एमुलेटर को थोड़ा संशोधित कर सकते हैं। हाँ, और भी बहुत कुछ।



आपका दिन शुभ हो।