पायथन का उपयोग करते हुए फ़ेक्स एमुलेटर का रिमोट कंट्रोल

लेख में, मैं वर्णन करूंगा कि एनईएस एमुलेटर को दूरस्थ रूप से कैसे नियंत्रित किया जाए, और दूरस्थ रूप से कमांड भेजने के लिए एक सर्वर।

इसकी आवश्यकता क्यों है?

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

अब एनईएस का अनुकरण करने के लिए औसत प्रोसेसर की शक्ति पर्याप्त है, क्यों एमुलेटर में पायथन या जावास्क्रिप्ट जैसी शक्तिशाली स्क्रिप्टिंग भाषाओं का उपयोग नहीं किया जाता है?

दुर्भाग्य से, लोकप्रिय एनईएस एमुलेटरों में से किसी में भी इन या अन्य भाषाओं का उपयोग करने की क्षमता नहीं है। मुझे केवल एक छोटे से ज्ञात Nintaco प्रोजेक्ट मिला, जो कि किसी कारण से जावा में फिर से लिखे जाने के लिए Fceux कर्नेल पर आधारित है। फिर मैंने पायनियर को खुद को नियंत्रित करने के लिए पायथन में स्क्रिप्ट लिखने की क्षमता जोड़ने का फैसला किया।

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

यह कैसे काम करता है

एमुलेटर की तरफ

Fceux एमुलेटर में पहले से ही संकलित कोड के रूप में कई Lua लाइब्रेरी शामिल हैं। उनमें से एक है LuaSocket । यह खराब रूप से प्रलेखित है, लेकिन मैं Xkeeper0 लिपियों के संग्रह के बीच काम कोड का एक उदाहरण खोजने में कामयाब रहा। उन्होंने एमसर के माध्यम से एमुलेटर को नियंत्रित करने के लिए सॉकेट्स का इस्तेमाल किया। दरअसल, tcp सॉकेट खोलने वाला कोड है:

function connect(address, port, laddress, lport) local sock, err = socket.tcp() if not sock then return nil, err end if laddress then local res, err = sock:bind(laddress, lport, -1) if not res then return nil, err end end local res, err = sock:connect(address, port) if not res then return nil, err end return sock end sock2, err2 = connect("127.0.0.1", 81) sock2:settimeout(0) --it's our socket object print("Connected", sock2, err2) 

यह एक निम्न-स्तरीय सॉकेट है जो 1 बाइट द्वारा डेटा प्राप्त करता है और भेजता है।

Fceux एमुलेटर में, लुआ स्क्रिप्ट का मुख्य लूप इस तरह दिखता है:

 function main() while true do --  passiveUpdate() --,        emu.frameadvance() --       end end 

सॉकेट से डेटा की जांच:

 function passiveUpdate() local message, err, part = sock2:receive("*all") if not message then message = part end if message and string.len(message)>0 then --print(message) local recCommand = json.decode(message) table.insert(commandsQueue, recCommand) coroutine.resume(parseCommandCoroutine) end end 

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

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

 gui.register(passiveUpdate) --undocumented. this function will call even if emulator paused 

इसके साथ, आप passiveUpdate के अंदर अनुकरण करना बंद कर सकते हैं और जारी रख सकते हैं - इस तरह आप सॉकेट के माध्यम से एमुलेटर के ब्रेकप्वाइंट की स्थापना को व्यवस्थित कर सकते हैं।

सर्वर साइड कमांड

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

इस विचार को SyncCall वर्ग में लागू किया गया है:

 class syncCall: @classmethod def waitUntil(cls, messageName): """cycle for reading data from socket until needed message was read from it. All other messages will added in message queue""" while True: cmd = messages.parseMessages(asyncCall.waitAnswer(), [messageName]) #print(cmd) if cmd != None: if len(cmd)>1: return cmd[1] return @classmethod def call(cls, *params): """wrapper for sending [functionName, [param1, param2, ...]] to socket and wait until client return [functionName_finished, [result1,...]] answer""" sender.send(*params) funcName = params[0] return syncCall.waitUntil(funcName + "_finished") 

इस वर्ग के साथ, पायस एमुलेटर लुआ विधियों को पायथन कक्षाओं में लपेटा जा सकता है:

 class emu: @classmethod def poweron(cls): return syncCall.call("emu.poweron") @classmethod def pause(cls): return syncCall.call("emu.pause") @classmethod def unpause(cls): return syncCall.call("emu.unpause") @classmethod def message(cls, str): return syncCall.call("emu.message", str) @classmethod def softreset(cls): return syncCall.call("emu.softreset") @classmethod def speedmode(cls, str): return syncCall.call("emu.speedmode", str) 

और फिर लुआ से उसी तरह वर्बेटिम कहा जाता है:

 # : emu.poweron() 

कॉलबैक विधियाँ

लुआ में, आप कॉलबैक पंजीकृत कर सकते हैं - एक निश्चित स्थिति पूरी होने पर कॉल किए जाने वाले फ़ंक्शन। हम निम्न चाल का उपयोग करके पायथन में सर्वर के लिए इस व्यवहार को पोर्ट कर सकते हैं। सबसे पहले, हम पायथन में लिखे गए कॉलबैक फ़ंक्शन के पहचानकर्ता को सहेजते हैं और इसे Lua कोड में भेजते हैं:

 class callbacks: functions = {} callbackList = [ "emu.registerbefore_callback", "emu.registerafter_callback", "memory.registerexecute_callback", "memory.registerwrite_callback", ] @classmethod def registerfunction(cls, func): if func == None: return 0 hfunc = hash(func) callbacks.functions[hfunc] = func return hfunc @classmethod def error(cls, e): emu.message("Python error: " + str(e)) @classmethod def checkAllCallbacks(cls, cmd): #print("check:", cmd) for callbackName in callbacks.callbackList: if cmd[0] == callbackName: hfunc = cmd[1] #print("hfunc:", hfunc) func = callbacks.functions.get(hfunc) #print("func:", func) if func: try: func(*cmd[2:]) #skip function name and function hash and save others arguments except Exception as e: callbacks.error(e) pass #TODO: thread locking sender.send(callbackName + "_finished") 

लुआ-कोड इस पहचानकर्ता को भी बचाता है और एक नियमित लुआ-कॉलबैक को पंजीकृत करता है, जो पायथन-कोड पर नियंत्रण स्थानांतरित करेगा। अगला, पायथन कोड में एक अलग धागा बनाया गया है जो केवल इस बात की जाँच करने के लिए चिंतित है कि लुआ से कॉलबैक कमांड स्वीकार नहीं किया गया है:

 def callbacksThread(): cycle = 0 while True: cycle += 1 try: cmd = messages.parseMessages(asyncCall.waitAnswer(), callbacks.callbackList) if cmd: #print("Callback received:", cmd) callbacks.checkAllCallbacks(cmd) pass except socket.timeout: pass time.sleep(0.001) 

अंतिम चरण यह है कि पायथन कॉलबैक निष्पादित होने के बाद, एमुलेटर को कॉलबैक समाप्त होने की सूचना देने के लिए " CALLBACKNAME_finished " कमांड का उपयोग करके Lua पर नियंत्रण वापस आ जाता है।

एक उदाहरण कैसे चलाएं

• आपके पास सिस्टम पर Python 3 और Jupyter नोटबुक होना चाहिए। आपको जुपिटर को कमांड से चलाना होगा
  
  

   jupyter notebook 

  
  
• FceuxPythonServer.py.ipynb लैपटॉप खोलें और पहली पंक्ति चलाएँ
  
  
• अब आपको फ़ेसक्स एमुलेटर को चलाने की ज़रूरत है, इसमें रोम फ़ाइल खोलें (मैं गेम किल्वेनिया (यू) (PRG0) [!] का उपयोग करता हूं । मेरे उदाहरण में । ) और लुइस स्क्रिप्ट को fceux -listener.lua नाम से चलाएं । यह जुपिटर लैपटॉप पर चल रहे सर्वर से कनेक्ट होना चाहिए।
  
  कमांड लाइन का उपयोग करके ये क्रियाएं की जा सकती हैं:
  
  

   fceux.exe -lua fceux_listener.lua "Castlevania (U) (PRG0) [!].nes" 

  
  
• अब ज्यूपिटर नोटबुक पर वापस जाएं। आपको एमुलेटर के सफल कनेक्शन के बारे में संदेश देखना चाहिए:
  
  
  

बस इतना ही, आप सीधे ब्राउज़र में जुपाइटर लैपटॉप से ​​Fceux emulator पर कमांड भेज सकते हैं।

आप उदाहरण के सभी लाइनों को क्रमिक रूप से निष्पादित कर सकते हैं और एमुलेटर में निष्पादन के परिणाम का निरीक्षण कर सकते हैं।

पूर्ण उदाहरण:
https://github.com/spiiin/fceux_luaserver/blob/master/FceuxPythonServer.py.ipynb

इसमें मेमोरी पढ़ने जैसे सरल कार्य शामिल हैं:



अधिक जटिल कॉलबैक उदाहरण:



और एक विशिष्ट गेम की स्क्रिप्ट जो आपको सुपर मारियो ब्रदर्स से दुश्मनों को स्थानांतरित करने की अनुमति देती है । माउस के साथ:



लैपटॉप रन वीडियो:

सीमाएं और अनुप्रयोग

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

संभावित अनुप्रयोग विचार:

• अन्य एमुलेटर और भाषाओं के लिए इस तरह के नियंत्रण के कार्यान्वयन के एक उदाहरण के रूप में
• खेल अनुसंधान
• TAS मार्ग व्यवस्थित करने के लिए धोखा या सुविधाएँ जोड़ना
• गेम में डेटा और कोड डालें या निकालें
• एमुलेटर की क्षमताओं को बढ़ाना - डिबगर्स लिखना, वॉकथ्रू को रिकॉर्ड करने और देखने के लिए स्क्रिप्ट, स्क्रिप्ट लाइब्रेरी, गेम एडिटर
• नेटवर्क गेम, मोबाइल उपकरणों का उपयोग करके गेम कंट्रोल, क्लाउड सेवाओं में सेविंग और पैच, रिमोट सर्विसेज, हैप्पीपैड या अन्य कंट्रोल डिवाइस
• क्रॉस-एमुलेटर विशेषताएं
• डेटा विश्लेषण और गेम कंट्रोल (बॉट्स बनाना) के लिए पायथन या अन्य भाषा पुस्तकालयों का उपयोग करना

प्रौद्योगिकी ढेर

मैंने इस्तेमाल किया:

Fceux - www.fceux.com/web/home.html
यह एक क्लासिक एनईएस एमुलेटर है, और ज्यादातर लोग इसका उपयोग करते हैं। यह लंबे समय तक अपडेट नहीं किया गया है, और सुविधाओं में सर्वश्रेष्ठ नहीं है, लेकिन यह कई रोमहैकर्स के लिए डिफ़ॉल्ट एमुलेटर है। इसके अलावा, मैंने इसे चुना क्योंकि लुका सॉकेट समर्थन इसमें एकीकृत है, और इसे स्वयं कनेक्ट करने की कोई आवश्यकता नहीं है।

Json.lua - github.com/spiiin/json.lua
यह शुद्ध Lua में JSON कार्यान्वयन है। मैंने इसे चुना क्योंकि मैं एक उदाहरण बनाना चाहता था जिसमें कोड संकलन की आवश्यकता नहीं है। लेकिन मुझे अभी भी पुस्तकालय को कांटा जाना था, क्योंकि Fceux में निर्मित कुछ पुस्तकालयों ने पुस्तकालय समारोह को रोक दिया और क्रमबद्धता को तोड़ दिया (मूल पुस्तकालय के लेखक के लिए मेरा अस्वीकृत पूल अनुरोध )।

पायथन 3 - www.python.org
Fceux Lua सर्वर tcp सॉकेट को खोलता है और इससे प्राप्त कमांड के लिए सुनता है। एमुलेटर पर कमांड भेजने वाला सर्वर किसी भी भाषा में लागू किया जा सकता है। मैंने अपने "बैटरी शामिल" दर्शन के लिए पायथन को चुना - अधिकांश मॉड्यूल मानक पुस्तकालय (सॉकेट और जेएसएन के साथ ही काम कर रहे हैं) में शामिल हैं। पायथन भी तंत्रिका नेटवर्क के साथ काम करने के लिए पुस्तकालय को जानता है, और मैं उन्हें एनईएस गेम में बॉट बनाने के लिए उपयोग करने का प्रयास करना चाहता हूं।

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

डेक्सपॉट - www.dexpot.de
मैंने इस वर्चुअल डेस्कटॉप मैनेजर का उपयोग दूसरों के ऊपर एमुलेटर विंडो को डॉक करने के लिए किया है। एमुलेटर विंडो में परिवर्तनों के त्वरित ट्रैकिंग के लिए सर्वर को पूर्ण स्क्रीन में तैनात करते समय यह बहुत सुविधाजनक है। मानक विंडोज टूल आपको दूसरों के शीर्ष पर खिड़की के डॉकिंग को व्यवस्थित करने की अनुमति नहीं देते हैं।

संदर्भ

दरअसल, प्रोजेक्ट रिपॉजिटरी है ।

Nintaco - दूरस्थ प्रबंधन के साथ जावा NES एमुलेटर
Xkeeper0 emu-lua संग्रह - विभिन्न Lua लिपियों का संग्रह
मेसन C # में एक आधुनिक NES एमुलेटर है जिसमें शक्तिशाली Lua स्क्रिप्टिंग क्षमताएं हैं। अब तक सॉकेट समर्थन और रिमोट कंट्रोल के बिना।
CadEditor एनईएस और अन्य प्लेटफार्मों के लिए एक सार्वभौमिक स्तर के संपादक के साथ-साथ खेलों पर शोध करने के लिए शक्तिशाली उपकरण की मेरी परियोजना है। मैं खेल का पता लगाने और उन्हें संपादक में जोड़ने के लिए पोस्ट में वर्णित स्क्रिप्ट और सर्वर का उपयोग करता हूं।

मैं स्क्रिप्ट का उपयोग करने के लिए प्रतिक्रिया, परीक्षण और प्रयासों की सराहना करूंगा।