डेटा को प्रोसेस और स्टोर करने के लिए Lua और C ++ का उपयोग करना

लेख कोड यहां पाया जा सकता है ।

लुआ इतना अच्छा क्यों है?

एक बार जब मैंने अपना गेम विकसित किया और खुद से पूछा: कॉन्फ़िगरेशन फ़ाइलों के लिए कौन से डेटा प्रारूप का उपयोग करना बेहतर है?
यह सुविधाजनक है, जब आप एक वस्तु बनाते हैं, विभिन्न प्रारंभिक मापदंडों को कोड में नहीं, बल्कि अलग-अलग फाइलों में सेट करने के लिए। यह आपको पुनर्संयोजन के बिना वस्तुओं के कुछ मापदंडों को बदलने की अनुमति देता है, और वास्तव में प्रोग्रामिंग से दूर के लोगों के लिए उन्हें बदलना संभव बनाता है।
डेवलपर्स विभिन्न स्वरूपों का उपयोग करते हैं: कुछ JSON का उपयोग करते हैं, अन्य XML या अन्य डेटा स्वरूपों का उपयोग करते हैं। खैर, कुछ आम तौर पर .txt फ़ाइलों में डेटा संग्रहीत करते हैं या अपने पार्सर लिखते हैं। विभिन्न प्रारूपों की समीक्षा के बाद, मैं लुआ पर बस गया।

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

यहाँ अन्य स्वरूपों से अलग Lua सेट है:

• Lua अतिरिक्त निर्भरता के बिना उपयोग करना आसान है (एक Lua पुस्तकालय और तीन .h फ़ाइलों को छोड़कर)।
• Lua फ़ाइलों में, गणितीय अभिव्यक्तियों या Lua में लिखे कार्यों का उपयोग करके डेटा को आरंभ किया जा सकता है। उदाहरण के लिए:
  

  some_variable = math.sqrt(2) * 2 some_variable2 = 64 * 16 - 32 

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

चलो एक सरल उदाहरण से शुरू करते हैं, और फिर मैं कक्षा को लागू करने के लिए आगे बढ़ूंगा।

उदाहरण

मान लीजिए कि एक Player.lua फ़ाइल है

 player = { pos = { X = 20, Y = 30, }, filename = "res/images/player.png", HP = 20, --      } 

एक साधारण वर्ग के साथ, डेटा इस प्रकार प्राप्त किया जा सकता है:

 LuaScript script("player.lua"); std::string filename = script.get<std::string>("player.filename"); int posX = script.get<std::string>("player.pos.X"); 

ध्यान दें कि कोड समझ में आता है, यह जानकारी पढ़ने की सिफारिश की जाती है कि लूआ स्टैक कैसे काम करता है और सबसे सरल उदाहरणों को देखता है।
आप यहाँ पढ़ सकते हैं ।

चलो एक वर्ग बनाकर शुरू करते हैं:

 #ifndef LUASCRIPT_H #define LUASCRIPT_H #include <string> #include <vector> #include <iostream> // Lua   C,    ,        C extern "C" { # include "lua.h" # include "lauxlib.h" # include "lualib.h" } class LuaScript { public: LuaScript(const std::string& filename); ~LuaScript(); void printError(const std::string& variableName, const std::string& reason); template<typename T> T get(const std::string& variableName) { //       } bool lua_gettostack(const std::string& variableName) { //     .   -  true //   } //  0   template<typename T> T lua_get(const std::string& variableName) { return 0; } //     ,          - //    template<typename T> T lua_getdefault(const std::string& variableName) { return 0; } private: lua_State* L; int level; // .  lug_gettostack }; #endif 

डिजाइनर:

 LuaScript::LuaScript(const std::string& filename) { L = luaL_newstate(); if (luaL_loadfile(L, filename.c_str()) || lua_pcall(L, 0, 0, 0)) { std::cout<<"Error: script not loaded ("<<filename<<")"<<std::endl; L = 0; } } 

।
हम lua_State बनाते हैं, अगर फ़ाइल नहीं मिली, या कोई अन्य त्रुटि हुई, तो हम इस बारे में एक संदेश प्रदर्शित करते हैं।
नाशक:

 LuaScript::~LuaScript() { if(L) lua_close(L); } 

PrintError विधि त्रुटि संदेशों को प्रदर्शित करने के लिए डिज़ाइन की गई है:

 void LuaScript::printError(const std::string& variableName, const std::string& reason) { std::cout<<"Error: can't get ["<<variableName<<"]. "<<reason<<std::endl; } 

यदि कोई त्रुटि होती है, तो nua मान को वापस करने के लिए lua_getdefault का उपयोग किया जाता है। और यदि संख्याओं के लिए शून्य वापस किया जा सकता है, तो स्ट्रिंग के लिए, उदाहरण के लिए, यह काम नहीं करेगा, इसलिए हम टेम्पलेट को विशेषज्ञ करते हैं (यह कोड हेडर में होगा)।

 template<> inline std::string LuaScript::lua_getdefault<std::string>() { return "null"; } 

और अब हम एक टेम्पलेट फ़ंक्शन प्राप्त करते हैं ।
सबसे पहले, lua_gettostack फ़ंक्शन लिखें, जो स्टैक के ऊपर चर डालता है
आइए एक उदाहरण का उपयोग करके एल्गोरिथ्म का विश्लेषण करें। चलो चर "Player.pos.X" फ़ाइल Player.lua से प्राप्त करते हैं
हम पहले अक्षर के माध्यम से लूप करते हैं, जबकि रीड कैरेक्टर्स को "var" में जोड़ते हैं।
"प्लेयर" एक तालिका है जो वैश्विक है, इसलिए इसे lua_getglobal का उपयोग करके प्राप्त करें ।
"स्थिति" और "एक्स" पहले से ही डेटा है जो वैश्विक नहीं है, लेकिन lua_getfield का उपयोग करके प्राप्त किया जा सकता है, क्योंकि खिलाड़ी तालिका खुद स्टैक के शीर्ष पर है।
फिर, पहले से ही टेम्पलेट फ़ंक्शन मिलता है, डेटा प्रकार के लिए एक फ़ंक्शन को निष्पादित किया जाता है, स्टैक को साफ़ किया जाता है और वांछित मान वापस किया जाता है, और एक त्रुटि के मामले में, lua_getdefault फ़ंक्शन को कहा जाता है ।

 bool lua_gettostack(const std::string& variableName) { level = 0; std::string var = ""; for(unsigned int i = 0; i < variableName.size(); i++) { if(variableName.at(i) == '.') { if(level == 0) { lua_getglobal(L, var.c_str()); } else { lua_getfield(L, -1, var.c_str()); } if(lua_isnil(L, -1)) { printError(variableName, var + " is not defined"); return false; } else { var = ""; level++; } } else { var += variableName.at(i); } } if(level == 0) { lua_getglobal(L, var.c_str()); } else { lua_getfield(L, -1, var.c_str()); } if(lua_isnil(L, -1)) { printError(variableName, var + " is not defined"); return false; } //  ,  true return true; } 

वापस पाने के लिए विधि प्राप्त करें :

 template <typename T> T get(const std::string& variableName) { if(!L) { printError(variableName, "Script is not loaded"); return lua_getdefault<T>(); } T result; if(lua_gettostack(variableName)) { //  ,     result = lua_get<T>(variableName); } else { result = lua_getdefault<T>(); } lua_pop(L, level + 1); //   return result; } } 

यह केवल टेम्पलेट विशेषज्ञता (कुछ डेटा प्रकारों के लिए एक उदाहरण) जोड़ने के लिए बनी हुई है:

 template <> inline bool LuaScript::lua_get<bool>(const std::string& variableName) { return (bool)lua_toboolean(L, -1); } template <> inline float LuaScript::lua_get<float>(const std::string& variableName) { if(!lua_isnumber(L, -1)) { printError(variableName, "Not a number"); } return (float)lua_tonumber(L, -1); } template <> inline int LuaScript::lua_get<int>(const std::string& variableName) { if(!lua_isnumber(L, -1)) { printError(variableName, "Not a number"); } return (int)lua_tonumber(L, -1); } template <> inline std::string LuaScript::lua_get<std::string>(const std::string& variableName) { std::string s = "null"; if(lua_isstring(L, -1)) { s = std::string(lua_tostring(L, -1)); } else { printError(variableName, "Not a string"); } return s; } 

वह सब है। मैं आपको याद दिलाता हूं कि लेख के सभी कोड यहां हैं । आप वहां कक्षा का उपयोग करने का एक उदाहरण भी पा सकते हैं।

आगे क्या है?

लूआ में कई और विशेषताएं हैं जो मैं निकट भविष्य में लेख के दूसरे भाग में वर्णन करूंगा। उदाहरण के लिए, अनिश्चित लंबाई के डेटा की एक सरणी प्राप्त करना, साथ ही तालिका कुंजियों की एक सूची प्राप्त करना (उदाहरण के लिए, उदाहरण के लिए प्लेयर तालिका के लिए, यह इस तरह होगा: ["pos", "फ़ाइल नाम", "HP"])
आप लुआ से सी ++ फ़ंक्शंस भी कॉल कर सकते हैं, जैसे आप सी ++ से लुआ फ़ंक्शंस को कॉल कर सकते हैं, जिसके बारे में मैं तीसरे भाग में लिखूंगा।
एक अच्छी स्क्रिप्टिंग है!