👩🏼 ⏯️ ⏮️ अपनी आंखों के सामने एक गेम बनाना - भाग 3: हम स्क्रिप्टिंग भाषा को एकता (UniLua) में बांध देते हैं 👨‍🏭 🤸 🤹🏻

जैसा कि वादा किया गया था, मैं आपके साथ उन तकनीकी विवरणों को साझा करना जारी रखता हूं जिनका सामना हम अपने खेल को बनाने की प्रक्रिया में करते हैं।

इस बार, चलो इन-गेम स्क्रिप्ट लिखने के लिए एक भाषा के बारे में बात करते हैं।

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

मुझे तुरंत कहना होगा कि इंटरनेट पर नवीनतम जानकारी लगभग शून्य है, और इस शून्य का आधा चीनी में है। तो, आप कह सकते हैं - अनन्य रखें।

हमें स्क्रिप्ट की आवश्यकता क्यों है?

हमारे खेल में, हमें कई तरह के पटकथा वाले दृश्यों को दिखाना होगा।

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

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

जाहिर है, ऐसी चीजों को हार्डकोर करना बिल्कुल भी मुश्किल नहीं है।

क्यों लुआ?

दरअसल, शुरुआत में खुद की साइकिल और लुआ के बीच एक विकल्प था।

ऐसा लगता है कि पहले दृष्टिकोण से भाषा को बहुत अधिक आवश्यकता नहीं है और आप अपना खुद का लिख सकते हैं। क्रम में अपने आप को टीमों को बुलाओ और यह है। लेकिन अगर आप थोड़ा गहराई से सोचते हैं ... तो क्या स्क्रिप्ट की घटनाएँ खेल के मापदंडों से संबंधित होंगी? उदाहरण के लिए, पहले से मारे गए एनपीसी दृश्यों में दिखाई नहीं देना चाहिए। या ऐसा कुछ और। और यह पहले से ही कुछ शर्तों, ट्रिगर आदि का मतलब है।

नतीजतन, एक "सरल भाषा" के पार्सर के परिणामस्वरूप बहुत जटिल गर्भपात हो सकता है, जिसे तार्किक अभिव्यक्तियों के ढेर को पार्स करने की आवश्यकता होगी, आदि। आदि

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

तो, फिर से, - यह दूसरों द्वारा सत्यापित एक समाधान का उपयोग करने का निर्णय लिया गया था।

एकता में एकता

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

और हम एक पुस्तकालय चाहेंगे जो हर जगह (केवल मामले में) समर्थित होगा और अधिमानतः पूरी तरह से स्रोतों के साथ होगा, और एक बंद डीएलएल में नहीं।

इंटरनेट के माध्यम से अफवाह के कारण, हमें चीनी प्रोग्रामर - यूनीलुआ का एक मुफ्त निर्माण मिला। हर जगह पूरी तरह से और काम करता है।

यह सभी के लिए अच्छा है सिवाय इसके कि डॉक अविश्वसनीय रूप से अल्प और आंशिक रूप से चीनी में लिखे गए हैं।

ओह ठीक है, हमारे पास स्रोत है! और मस्तिष्क ... =) डाउनलोड, UniLua फ़ोल्डर को प्लगइन्स में ड्रॉप करें (ताकि हर बार recompiled न हो) और जाएं।

C # से Lua स्क्रिप्ट को कॉल करें

यहां सब कुछ अपेक्षाकृत सरल है:

using UniLua; private ILuaState _lua; //        Lua private ThreadStatus _status; //       ... _lua = LuaAPI.NewState(); //  string lua_script = ""; //      Lua _status = _lua.L_LoadString(lua_script); //   if (_status != ThreadStatus.LUA_OK) { Debug.LogError("Error parsing lua code"); } _status.Call(0, 0); //  Lua-

आप चलाने की कोशिश कर सकते हैं। अगर किसी ने शाप नहीं दिया, तो सब ठीक है। एक खाली स्क्रिप्ट सफल हुई।

लुआ से कॉलिंग # कार्य

अब हमें कम से कम इस लिपि के बारे में जानने की आवश्यकता है। जाहिर है, हमें लुआ से C # कोड कॉल करने के लिए सीखने की जरूरत है।

आइए एक विधि लिखें जो लॉग में एक पैरामीटर लिखता है:

 private int L_Trace(ILuaState s) { Debug.Log("Lua trace: " + s.L_CheckString(1)); //    return 1; //   }

जैसा कि आप देख सकते हैं, हमने ILuaState वर्ग का उपयोग किया। यह वह जगह है जहां सभी इनपुट मापदंडों को संग्रहीत किया जाता है (जिसे हम लुआ से स्थानांतरित करना चाहते हैं और यह वहां है कि हमें परिणाम वापस करने की आवश्यकता है। कृपया ध्यान दें! लुआ में परिणाम return माध्यम से नहीं लौटाया जाता है, लेकिन s.PushInteger() , s.PushString() , आदि के माध्यम से।

फंक्शन लिखा है। अब आपको इसे लुआ से जोड़ने की आवश्यकता है।

  private int OpenLib(ILuaState lua) { var define = new NameFuncPair[] // ,     ( Lua -> C#) { new NameFuncPair("trace", L_Trace), }; lua.L_NewLib(define); return 1; }

अगला, _lua ऑब्जेक्ट बनाने के बाद, हमें इस लाइब्रेरी विवरण से एक कनेक्शन जोड़ना होगा:

 _lua.L_OpenLibs(); _lua.L_RequireF("mylib", OpenLib, true);

हो गया! अब आप यह कर सकते हैं:

 string lua_script = @" local lib = require ""mylib"" lib.trace(""Test output"") ";

ऐसा लगता होगा कि सब? लेकिन नहीं। अब सबसे कठिन हिस्सा है।

उपज

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

यह यहां था कि मैंने कई प्रतियां तोड़ दीं। यह कैसे करें का एक व्याख्यात्मक वर्णन बहुत मुश्किल था (और यह एक अन्य पुस्तकालय के लिए था)।

पहली चीज़ जो हमें चाहिए वो होगी स्क्रिप्ट को कॉल से नहीं, बल्कि एक अलग धागे के ज़रिए चलाना:

 //_status.Call(0, 0);     .   : _thread = _lua.NewThread(); _status = _thread.L_LoadString(lua_script); _thread.Resume(null, 0);

अब कल्पना करें कि C # में हमने फ़ंक्शन को "एनीमेशन समाप्त होने की प्रतीक्षा करें" ( L_WaitForAnimationStop ) L_WaitForAnimationStop , जिसे हम लुआ से कहते हैं। यहां कार्यान्वयन अलग हो सकता है, फिर मैं सामान्य सिद्धांत का वर्णन करूंगा।

इस फ़ंक्शन में, हमें इस एनीमेशन के अंत में किसी तरह के कॉलबैक को लटका देना होगा, और सबसे महत्वपूर्ण बात - बदले return 1 बजाय return 1 हमें यह करना चाहिए:

  private int L_WaitForAnimationStop(ILuaState s) { //    callback'  .. _temp_state = s; //  ILuaState     return s.YieldK(s.GetTop(), 0, null); //  Lua,       }

और सीधे कॉलबैक में, हमें उस स्थान से स्क्रिप्ट को निष्पादित करना जारी रखना होगा जहां यह रुका था

 if (_temp_state.GetTop() > 0) _thread.Resume(null, 0);

वह सब है। अब एक स्क्रिप्ट की तरह:

 lib.trace("starting") lib.wait_for_animation_stop() lib.trace("stopped")

lib.wait_for_animation_stop() बाद lib.wait_for_animation_stop() और केवल तब ही जारी रहेगा जब आप इसे चाहते हैं (यानी, उपरोक्त मामले में, कॉलबैक कॉल करें, जो Resume() करेगा Resume() )।

क्या हासिल हुआ है

उपरोक्त विधि का उपयोग, साथ ही ओओपी का अनुकरण करने के लिए शर्मिंदगी , निम्नलिखित सिंटैक्स को प्राप्त करना संभव था:

 local ch1 = CharacterGfx() ch1.create("char_0") local ch2 = CharacterGfx() ch2.create("char_1") ch1.moveto("workout") ch2.moveto("fridge") ch2.wait_move_finish() ch1.wait_move_finish() vh.trace("finished ok")

स्क्रिप्ट दो अक्षर स्प्राइट बनाती है, पहली को "वर्कआउट" बिंदु पर ले जाती है, दूसरा "फ्रिज" पॉइंट पर ले जाती है, फिर दोनों अपने आंदोलन को समाप्त करने के लिए प्रतीक्षा करती है, और उसके बाद ही "समाप्त हुआ" लिखती है।

प्रलेखन से, मैं केवल Lua 5.2 संदर्भ नियमावली की सलाह दे सकता हूं, जहां इन सभी shamanism का वर्णन किया गया है, एक और कार्यान्वयन के लिए थोड़ा सा।

श्रृंखला के सभी लेख:

अपनी आंखों के सामने एक गेम बनाना - भाग 3: हम स्क्रिप्टिंग भाषा को एकता (UniLua) में बांध देते हैं