भाषा जाओ। हम CHIP-8 एमुलेटर लिखते हैं

गो ने हाल ही में अपने जीवन का पहला वर्ष मनाया है। दुभाषिया सीएचआईपी -8 पहले से ही चालीस के नीचे मारा।

यह पोस्ट नई भाषाओं और पुराने हार्डवेयर के प्रशंसकों के लिए समर्पित है - इसमें हम गो में CHIP-8 वर्चुअल मशीन का एक एमुलेटर लिखेंगे।



हमने पहले ही लिखा है कि गो के साथ काम करने के लिए पर्यावरण को एक से अधिक बार कैसे सेट करें। हाल ही में, थोड़ा बदल गया है, सिवाय इसके कि विंडोज के लिए संस्करण अधिक स्थिर हो गया है।

निर्देशों के अनुसार सब कुछ स्थापित करने के बाद, हम CHIP-8 के इनसाइट्स का अध्ययन करने के लिए आगे बढ़ते हैं।

कहानी

CHIP-8 पर आधारित गेम कंसोल इतिहास में पहली आभासी मशीनों में से एक होने के लिए उल्लेखनीय हैं।

CHIP-8 के कार्यक्रमों को एक वास्तविक प्रोसेसर पर निष्पादित नहीं किया जाता है, लेकिन इसकी व्याख्या की जाती है। इसके अलावा, मूल दुभाषिया केवल 512 बाइट्स लिया।

CHIP-8 की विशेषताएं प्रभावशाली रूप से विनम्र हैं: मेगाहर्ट्ज़ के एक जोड़े की आवृत्ति के साथ एक 8-बिट प्रोसेसर, 4 केबी रैम (प्रोग्राम कोड भी रैम में संग्रहीत है), एक मोनोक्रोम 32x64 पिक्सेल स्क्रीन, दो टाइमर - गिनती के समय के लिए एक, ध्वनि खेलने के लिए एक ("ट्वीटर") )।

सभी दोषों के बावजूद, CHIP-8 में अंतरिक्ष आक्रमणकारियों, पोंग, और अन्य पुराने स्कूल के खेलों को लॉन्च करने की पर्याप्त शक्ति थी।

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

परियोजना की संरचना

हमारे एमुलेटर में एकल c8emu.go फ़ाइल शामिल होगी ...

 //   ""   Go package main func main() { }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

... और मेकफाइल:

 #  Makefile   Go include $(GOROOT)/src/Make.inc TARG=c8emu GOFILES=c8emu.go include $(GOROOT)/src/Make.cmd
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

नीचे दिए गए स्रोत कोड को समझना आसान बनाने के लिए, मुझे याद है कि:

• गो में अर्धविराम वैकल्पिक हैं; यदि कथन भी वैकल्पिक हैं / हैं। बाकी भाषा C / Java के समान है। गो में चर को कई तरीकों से घोषित किया जा सकता है (हां, उल्टा बनाम सी):
  
  var i int

var i int = 0

i := 0
  
  
  
  
• छोरों के लिए केवल एक बयान है - के लिए
  
  for i:=0; i<10; i++ { .. }

for cond == true { ... }

for { }
  
  
  
  
• आप कार्रवाई कर सकते हैं और एक ऑपरेटर में इसका परिणाम देख सकते हैं:
  
  if err = DoSomethin(); err != nil { fmt.Println("Error: "+err) }
  
  
  
  
• निजी / सार्वजनिक तरीके और विशेषताएं केवल मामले में भिन्न होती हैं:
  
  someMethod() //

SomeMethod() //


  
  
  
  

बेशक, भाषा में बहुत अधिक विशेषताएं हैं, और वे सभी असामान्य लगते हैं, लेकिन सख्ती से न्याय नहीं करते हैं। भाषा बस अलग है।



इसलिए, CHIP-8 का अनुकरण करने के लिए, हमें एक उपयुक्त वर्ग की आवश्यकता है (गो में कोई कक्षाएं नहीं हैं, लेकिन संरचना के साथ काम करने के लिए फ़ील्ड और विधियों के साथ संरचनाएं हैं):

 type Chip8 struct { memory []byte // memory address is in range: 0x200...0xfff regs [16]byte // CHIP-8 has 16 8-bit registers ireg uint16 // I-reg was a 16-bit register for memory operations stack [16]uint16 // Stack up to 16 levels of nesting sp int // Stack pointer pc uint16 // Program counter }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह संरचना CHIP-8: एक मेमोरी ब्लॉक, 16 आठ-बिट रजिस्टरों, रजिस्टर-पॉइंटर I, 16 नेस्टिंग स्तरों के एक स्टैक के साथ-साथ एक कमांड काउंटर और स्टैक पॉइंटर का वर्णन करती है।

एमुलेटर इनिशियलाइज़ेशन

हमारी CHIP-8 ऑब्जेक्ट बनाने के लिए, हम NewChip8()



फ़ंक्शन NewChip8()



:

 func NewChip8() (c *Chip8) { c = new(Chip8); //     c.memory = make([]byte, 0xfff) //  "" ( )   c.sp = 0 c.pc = 0x200 //   CHIP-8    0x200 c.ireg = 0 //        return c }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

CHIP-8 दुभाषिया में प्रोग्राम कोड को लोड करने के लिए, हम लोड () विधि लिखते हैं। कार्यों के तरीके को समान रूप से वर्णित किया गया है:

 func (c *Chip8) Load(rom []byte) (err os.Error) { if len(rom) > len(c.memory) - 0x200 { //  len    (- ) err = os.NewError("ROM is too large!") // -    return } copy(c.memory[0x200:], rom) //     0200 err = nil return }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

निर्देश प्रसंस्करण

चरण () विधि आपको एक अलग CHIP-8 स्टेटमेंट निष्पादित करने की अनुमति देती है। सभी निर्देश 2-बाइट हैं। ऑपकोड अधिक या कम संरचित हैं, हालांकि एआरएम में बिल्कुल पसंद नहीं है ... मूल रूप से, आप कोड के उच्च 4 बिट्स द्वारा नेविगेट कर सकते हैं।

 func (c *Chip8) Step() (err os.Error) { var op uint16 //      if (c.pc >= uint16(len(c.memory))) { err = os.EOF return } //     op = (uint16(c.memory[c.pc]) << 8) | uint16(c.memory[c.pc + 1]) switch (op & 0xf000) >> 12 { case ... /*       */ default: return os.NewError("Illelal instruction") } c.pc += 2 return }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अधिकांश निर्देश बहुत तुच्छ हैं:

 // JMP addr - jump to address case 0x1: c.pc = op & 0xfff return // SKEQ reg, value - skip if register equals value case 0x3: if c.regs[(op & 0x0f00) >> 8] == byte(op & 0xff) { c.pc += 2 // skip one instruction } // SKNE reg, value - skip if not equal case 0x4: if c.regs[(op & 0x0f00) >> 8] != byte(op & 0xff) { c.pc += 2 // skip one instruction } // MOV reg, value case 0x6: c.regs[(op & 0x0f00) >> 8] = byte(op & 0xff) // MVI addr -   - I case 0xa: c.ireg = op & 0xfff // RAND reg, max -      0..max case 0xc: c.regs[(op & 0x0f00) >> 8] = byte(rand.Intn(int(op & 0xff)))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंकगणित और तार्किक निर्देशों को एक ही तरीके से संसाधित किया जाता है।

हैंडलिंग प्रक्रिया कॉल और उन्हें बाहर निकालना भी बहुत सरल लगता है:

 // RET -    ( 00EE) case 0x0: switch op & 0xff { case 0xee: c.sp-- c.pc = c.stack[c.sp] return } // CALL addr -     case 0x2: c.stack[c.sp] = c.pc + 2 c.sp++ c.pc = op & 0xfff return
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

मैं यहां सभी निर्देशों का वर्णन नहीं करूंगा। मैं तीन सबसे महत्वपूर्ण लोगों पर ध्यान केंद्रित करूँगा (उनका उपयोग लगभग किसी भी खेल में किया जाता है) - एक टाइमर के साथ काम करना और स्क्रीन पर चित्र प्रदर्शित करना।

घड़ी

टाइमर 60 हर्ट्ज की आवृत्ति पर संचालित होता है, एक संख्या (एक बाइट) इसमें दर्ज की जा सकती है, और यह प्रत्येक टिक के साथ 1 से घट जाएगी।

टाइमर को समय-समय पर पढ़ा जा सकता है और देख सकते हैं कि इसके लॉन्च के बाद से कितने "टिक" बीत चुके हैं। शून्य से नीचे, टाइमर मान नहीं जा सकता।

यहाँ परिणाम है:

 type Timer struct { value byte //      start int64 //   period int64 //    "" } //    func NewTimer(hz int) (t *Timer) { t = new(Timer) t.period = int64(1000000000/hz) t.value = 0 return t } //  func (t *Timer) Set(value byte) { t.value = value t.start = time.Nanoseconds() } //   func (t *Timer) Get() byte { delta := (time.Nanoseconds() - t.start) / t.period if int64(t.value) > delta { return t.value - byte(delta) } return 0 }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चिप 8 संरचना में एक टाइमर फ़ील्ड जोड़ें और चिप 8 ऑब्जेक्ट बनाते समय इसे इनिशियलाइज़ करें:

 type Chip8 struct { ... timer *Timer ... } func NewChip8() (c *Chip8) { ... c.timer = NewTimer(60) .. } case 0xf: switch (op & 0xff) { case 0x07: //    c.regs[(op & 0x0f00) >> 8] = c.timer.Get() case 0x15: //   c.timer.Set(c.regs[(op & 0x0f00) >> 8]) }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रदर्शन

स्क्रीन पर छवि प्रदर्शित करने के लिए केवल एक निर्देश है। सीएचआईपी -8 में ग्राफिक्स स्प्राइट की अवधारणा पर आधारित हैं। एक ही चौड़ाई के सभी स्प्राइट्स - 8 पिक्सेल, केवल ऊंचाई में भिन्न होते हैं।

उदाहरण के लिए, एक स्प्राइट जो एक क्रॉस को खींचता है, पाँच बाइट्स के अनुक्रम की तरह दिखता है:

 0x88 ; 10001000 0x50 ; 01010000 0x20 ; 00100000 0x50 ; 01010000 0x88 ; 10001000
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

निष्कर्ष से पहले, आपको स्प्राइट की शुरुआत के पते को निर्दिष्ट करना होगा, तदनुसार रजिस्टर I का मूल्य निर्धारित करना।

स्क्रीन पर स्प्राइट को प्रदर्शित करने के लिए, आपको किसी भी दो रजिस्टरों में निर्देशांक दर्ज करने और ड्रॉ निर्देश को कॉल करने की आवश्यकता है, जिसमें स्प्राइट की ऊंचाई को इंगित करना है:

 mvi x_sprite mov v0, 10 mov v1, 15 draw v0, v1, 5 ;    5    (10,15) x_sprite: db 0x88, 0x50, 0x20, 0x50, 0x88
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

लेकिन ड्रा सिर्फ आकर्षित नहीं करता है, यह स्प्राइट पिक्सल के साथ मौजूदा पिक्सल के XOR बनाता है। यह सुविधाजनक है - एक स्प्राइट को मिटाने के लिए इसे एक ही निर्देशांक में बार-बार प्रदर्शित किया जा सकता है।

इसके अलावा, यदि किसी भी पिक्सेल को 0 पर रीसेट किया गया है, तो vf रजिस्टर (आमतौर पर एक ध्वज रजिस्टर के रूप में उपयोग किया जाता है) का मान सेट करें।

Chip8 संरचना में "वीडियो बफर" की एक सरणी जोड़ें: स्क्रीन [64 * 32] बूल और ड्राइंग के लिए एक फ़ंक्शन लिखें:

 c.regs[0xf] = 0 for col:=0; col<8; col++ { for row:=0; row<int(size); row++ { px := int(x) + col py := int(y) + row bit := (c.memory[c.ireg + uint16(row)] & (1 << uint(col))) != 0 if (px < 64 && py < 32 && px >= 0 && py >= 0) { src := c.screen[py*64 + px] dst := (bit != src) // ,  XOR      c.screen[py*64 + px] = dst if (src && !dst) { c.regs[0xf] = 1 } } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

आगे क्या है?

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

मुझे लगता है कि मुझे एसडीएल का उपयोग करके ग्राफिक्स और कीबोर्ड को पेंच करना चाहिए (गो सफलतापूर्वक इसका समर्थन करता है)। गो चैनलों का उपयोग करके इंटरफ़ेस मॉड्यूल और सीएचआईपी -8 कोर को सिंक्रनाइज़ करना सुविधाजनक होगा।

मुझे उम्मीद है कि यह दिलचस्प होगा!