🧙🏻 ✌🏽 👲🏿 स्क्रिप्ट क्या हैं और उन्हें खाने के लिए क्या है

शुभ दोपहर, हब्बर!
मैंने इस विषय को स्क्रिप्ट पर लिखने का फैसला किया

आपको क्या जानने की जरूरत है?

सी ++ एक सभ्य स्तर पर (पाठ में टेम्पलेट होंगे - टेम्पलेट)
लुआ, एक बहुत ही हल्की पटकथा वाली भाषा। मैं इस पाठ की सलाह देता हूं।

क्यों एक .cpp फ़ाइल में गेम डायलॉग लिखना एक बड़ी गलती थी

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

लेकिन एक रास्ता है, ऊपर एक कट - स्क्रिप्ट का उपयोग करते हुए।

समस्या हल करना

“ठीक है, ऐसी चीजों के लिए खिलाड़ी की विशेषताओं के विवरण के साथ एक नियमित फ़ाइल पर्याप्त है। लेकिन क्या करें अगर तेजी से विकसित हो रहे प्रोजेक्ट में लगभग हर दिन आपको मुख्य खिलाड़ी के तर्क को थोड़ा बदलना पड़े, और इसलिए, प्रोजेक्ट को कई बार संकलित करें? "
अच्छा सवाल है। इस मामले में, सभी विशेषताओं या खेल के किसी अन्य भाग के साथ खिलाड़ी के तर्क का समर्थन करने वाली स्क्रिप्ट हमारी सहायता के लिए आती हैं।
स्वाभाविक रूप से, कुछ प्रोग्रामिंग भाषा के कोड के रूप में खिलाड़ी के तर्क को रखना सबसे सुविधाजनक है।
पहला विचार यह है कि अपनी स्क्रिप्टिंग भाषा की अपनी व्याख्या लिखने वाले को कुछ ही सेकंड में मस्तिष्क से निकाल दिया जाए। खिलाड़ी का तर्क निश्चित रूप से इतनी भयानक लागत के लायक नहीं है।
सौभाग्य से, C ++ के लिए विशेष स्क्रिप्टिंग भाषा पुस्तकालय हैं जो एक पाठ फ़ाइल को स्वीकार करते हैं और इसे निष्पादित करते हैं।

ऐसी ही एक पटकथा भाषा लुआ पर चर्चा की जाएगी।

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

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

हम सी ++ में - कार्यक्रम कुछ कार्य करते हैं, उन्हें स्क्रिप्ट में किसी नाम के तहत "रजिस्टर" करते हैं और इसे स्क्रिप्ट में कहते हैं। यही है, अगर हमने C ++ प्रोग्राम में खिलाड़ी की स्थिति निर्धारित करने के लिए सेटपोस (x, y) फ़ंक्शन को पंजीकृत किया है, तो, इस फ़ंक्शन को स्क्रिप्ट में सामना करने के बाद, स्क्रिप्ट भाषा लाइब्रेरी से "दुभाषिया" इस फ़ंक्शन को C ++ प्रोग्राम में कॉल करता है, बेशक; सभी तरीकों के हस्तांतरण के साथ।
कमाल है ना? :)

UPD: सावधान! एक उपयोगकर्ता ने मुझे ईमेल से संपर्क किया कि जब मैंने कोड अपलोड किया था, तो मैंने सभी त्रुटियों को पूरी तरह से समाप्त नहीं किया था - habrahabr.ru/post/196272/#comment_6850016
कीड़े ने हबर की अनुमति से कोड में घुसपैठ की
कोड के वर्गों को बदलें

template<class t> T MethodName();

पर

  template<class T> T MethodName();

और lua_CFunction के बजाय, lua_cfunction स्कीप
धन्यवाद!

मैं तैयार हूँ!

जब आप प्रोग्रामिंग भाषाओं की स्क्रिप्टिंग के लाभों को समझते हैं, तो यह शुरू होने का समय है!
डाउनलोड करें और Lua को github (विषय के नीचे) पर भंडार से शामिल करें, या उन्हें आधिकारिक वेबसाइट पर ले जाएं।

हम विजुअल स्टूडियो में एक कंसोल प्रोजेक्ट या Win32 (यह महत्वपूर्ण नहीं है) बनाते हैं (मेरे पास संस्करण 2012 है)

हम प्रोजेक्ट-> प्रॉपर्टीज-> कॉन्फ़िगरेशन प्रॉपर्टीज-> वीसी ++ डिटेल्स और "इनक्लूजन डायरेक्ट्रीज" और "लाइब्रेरी डायरेक्ट्रीज" में क्रमशः रिपॉजिटरी से लिब और लिब फोल्डर को जोड़ते हैं।

अब main.cpp फ़ाइल बनाएँ, इसमें लिखें:

 int main() { return 0; }

जैसा कि आप अनुमान लगा सकते हैं, मेरे पास एक कंसोल एप्लिकेशन है।

अब कोडिंग पर जाएं

मैं वादा करता हूं कि मैं हर पल ध्यान से समझाऊंगा

स्क्रिप्ट के लिए हमारी स्क्रिप्ट क्लास जिम्मेदार होगी। मैं Script.h / .cpp में उसी समय फ़ंक्शन घोषित और कार्यान्वित करूंगा
Script.cpp बनाएं और उसमें लिखें

 #include "Script.h"

Script.h बनाएं और उसमें लिखें

 #ifndef _SCRIPT_H_ #define _SCRIPT_H_ #endif

2 पंक्तियों के बाद और #endif से पहले हम स्क्रिप्ट के एक वर्ग को परिभाषित करते हैं
यह कोड फाइलों के आपसी समावेश को रोकने के लिए लिखा गया है। मान लीजिए कि Game.h फ़ाइल में Script.h, और Script.h फ़ाइल में Game.h शामिल है - एक गड़बड़! और इस कोड के साथ, समावेशन केवल 1 बार किया जाता है

अब हम इस कोड के अंदर लिखते हैं

 #pragma comment(lib,"lua.lib") extern "C" { #include <lua.h> #include <lualib.h> #include <lauxlib.h> }

पहली पंक्ति पुरालेख से lua.lib को जोड़ती है।
बाहरी "C" क्या है? तथ्य यह है कि लुआ सी में लिखा गया है और इसलिए पुस्तकालयों को जोड़ने के लिए ऐसा कोड आवश्यक है।

अगला कंसोल के साथ काम करने के लिए कई फ़ाइलों के लिए प्रसिद्ध है

 #include <stdio.h> #include <iostream> #include <sstream> using namespace std;

अब कक्षा की परिभाषा पर आते हैं

 class Script {

C ++ के लिए Lua लाइब्रेरी की सबसे महत्वपूर्ण वस्तु है lua_State, यह स्क्रिप्ट निष्पादन के लिए आवश्यक है

 private: lua_State *lua_state;

इसके बाद सार्वजनिक कार्य करें

 public: void Create();

यह फ़ंक्शन lua_State को प्रारंभ करता है

बनाएं ()

Script.cpp में इसकी परिभाषा

 void Script::Create() { lua_state = luaL_newstate(); static const luaL_Reg lualibs[] = { {"base", luaopen_base}, {"io", luaopen_io}, {NULL, NULL} }; for(const luaL_Reg *lib = lualibs; lib->func != NULL; lib++) { luaL_requiref(lua_state, lib->name, lib->func, 1); lua_settop(lua_state, 0); } }

पहली पंक्ति हम अपने lua_State को इनिशियलाइज़ करते हैं।
फिर हम "कनेक्टेड लाइब्रेरी" की एक सूची घोषित करते हैं। तथ्य यह है कि लुआ में "शुद्ध" रूप में केवल प्रिंट () फ़ंक्शन है। गणितीय और अन्य कार्यों के लिए, आपको विशेष पुस्तकालयों को जोड़ने और फिर उन्हें गणित के रूप में कॉल करने की आवश्यकता है। फ़ू, आधार.फू, io.foo। अन्य पुस्तकालयों को जोड़ने के लिए, lualibs में जोड़ें, उदाहरण के लिए, {"गणित", luaopen_math}। सभी पुस्तकालय नाम लुआओपेन के साथ शुरू होते हैं _..., लिलिब के अंत में {NULL, NULL ”होना चाहिए

  void Close();

यह सुविधा लुआ संसाधनों को मुक्त करती है।

बंद करें ()

उसकी परिभाषा

 void Script::Close() { lua_close(lua_state); }

बस lua_close () का उपयोग करें

 int DoFile(char* ScriptFileName);

और यह फ़ंक्शन फ़ाइल को निष्पादित करता है। इनपुट पर, यह फ़ाइल का नाम लेता है, उदाहरण के लिए, "C: \\ script.lua"।
यह इंट क्यों लौटता है? बस कुछ स्क्रिप्ट में वापसी हो सकती है, स्क्रिप्ट में व्यवधान आ सकता है और कुछ मूल्य वापस आ सकते हैं।

DoFile ()

उसकी परिभाषा

 int Script::DoFile(char* ScriptFileName) { luaL_dofile(lua_state,ScriptFileName); return lua_tointeger(lua_state, lua_gettop(lua_state)); }

जैसा कि आप देख सकते हैं, मैं स्क्रिप्ट निष्पादित करता हूं और एक इंट वापस करता हूं। लेकिन फ़ंक्शन न केवल इंट, बल्कि बूल और चार * भी लौटा सकता है, मैं हमेशा केवल संख्या (lua_toboolean, lua_tostring) लौटाता हूं

अब हम एक ऐसा फंक्शन बनाएंगे जो स्थिरांक (संख्याओं, तारों, कार्यों) को पंजीकृत करता है

  template<class t> void RegisterConstant(T value, char* constantname);

रजिस्टरकॉन्स्टैंट ()

हम पैटर्न के माध्यम से कार्य करते हैं। फ़ंक्शन कॉल उदाहरण:

 RegisterConstant<int>(13,"goodvalue");

उसकी परिभाषा

 template<> void Script::RegisterConstant<int>(int value, char* constantname) { lua_pushinteger(lua_state, value); lua_setglobal(lua_state,constantname); } template<> void Script::RegisterConstant<double>(double value, char* constantname) { lua_pushnumber(lua_state, value); lua_setglobal(lua_state,constantname); } template<> void Script::RegisterConstant<char>(char* value, char* constantname) { lua_pushstring(lua_state, value); lua_setglobal(lua_state,constantname); } template<> void Script::RegisterConstant<bool>(bool value, char* constantname) { lua_pushboolean(lua_state, value); lua_setglobal(lua_state,constantname); } template<> void Script::RegisterConstant<lua_cfunction>(lua_CFunction value, char* constantname) { lua_pushcfunction(lua_state, value); lua_setglobal(lua_state,constantname); }

कक्षा टी के प्रत्येक संभावित मूल्य के लिए, हम अपने कार्यों को परिभाषित करते हैं।
* कप्तान * अंतिम परिभाषा - फ़ंक्शन पंजीकरण
पंजीकरण के लिए उपयुक्त कार्य निम्नानुसार हैं:

 int Foo(lua_State*) { // ... return n; }

जहाँ n लौटाए गए मानों की संख्या है। यदि n = 2, तो लूआ में आप यह कर सकते हैं:

 a, b = Foo()

Lua पर मैनुअल पढ़ें यदि आप आश्चर्यचकित थे कि एक फ़ंक्शन कई मान लौटाता है :)

निम्न फ़ंक्शन लुआ के लिए एक तालिका बनाता है। यदि यह स्पष्ट नहीं है कि इसका क्या मतलब है, तो वहां तालिका एक सरणी की तरह है

  void Array();

ऐरे ()

उसका वर्णन

 void Script::Array() { lua_createtable(lua_state, 2, 0); }

निम्न फ़ंक्शन किसी तालिका में एक आइटम पंजीकृत करता है।

  template<class t> void RegisterConstantArray(T value, int index);

RegisterConstantArray ()

उसका वर्णन

 template void Script::RegisterConstantArray<int>(int value, int index) { lua_pushnumber(lua_state, index); lua_pushinteger(lua_state, value); lua_settable(lua_state, -3); } template void Script::RegisterConstantArray<double>(double value, int index) { lua_pushnumber(lua_state, index); lua_pushnumber(lua_state, value); lua_settable(lua_state, -3); } template void Script::RegisterConstantArray<char>(char* value, int index) { lua_pushnumber(lua_state, index); lua_pushstring(lua_state, value); lua_settable(lua_state, -3); } template void Script::RegisterConstantArray<bool>(bool value, int index) { lua_pushnumber(lua_state, index); lua_pushboolean(lua_state, value); lua_settable(lua_state, -3); } template void Script::RegisterConstantArray<lua_cfunction>(lua_CFunction value, int index) { lua_pushnumber(lua_state, index); lua_pushcfunction(lua_state, value); lua_settable(lua_state, -3); }

यदि आप लुआ को नहीं जानते हैं, तो आप शायद आश्चर्यचकित हैं कि इतने प्रकार एक सरणी में फिट होते हैं? :)
वास्तव में, एक तालिका तत्व में एक तालिका भी हो सकती है, मैं ऐसा कभी नहीं करता।

अंत में, पूरी की गई तालिका को पंजीकृत करने की आवश्यकता है

  void RegisterArray(char* arrayname);

रजिस्टरअरे ()

उसका वर्णन

 void Script::RegisterArray(char* arrayname) { lua_setglobal(lua_state, arrayname); }

कुछ खास नहीं

निम्नलिखित कार्य मुख्य रूप से केवल int foo (lua_State *) जैसे कार्यों के लिए अभिप्रेत हैं, जिन्हें Lua में पंजीकृत करने की आवश्यकता है।

उनमें से पहला - तर्कों की संख्या प्राप्त करता है

  int GetArgumentCount();

बनाएं ()

उसका वर्णन

 int Script::GetArgumentCount() { return lua_gettop(lua_state); }

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

निम्न फ़ंक्शन स्क्रिप्ट में फ़ंक्शन को दिए गए तर्क को प्राप्त करता है

  template<class t> T GetArgument(int index);

GetArgument ()

उसका वर्णन

 template int Script::GetArgument<int>(int index) { return lua_tointeger(lua_state,index); } template double Script::GetArgument<double>(int index) { return lua_tonumber(lua_state,index); } template char* Script::GetArgument<char>(int index) { return (char*)lua_tostring(lua_state,index); } template bool Script::GetArgument<bool>(int index) { return lua_toboolean(lua_state,index); }

आप पहले से वर्णित सभी प्रकार प्राप्त कर सकते हैं, टेबल और कार्यों को छोड़कर
सूचकांक तर्क की संख्या है। और पहला तर्क 1 से शुरू होता है।

अंत में, अंतिम फ़ंक्शन जो स्क्रिप्ट में मान लौटाता है

  template<class t> void Return(T value);

वापसी ()

उसका वर्णन

 template<> void Script::Return<int>(int value) { lua_pushinteger(lua_state,value); } template<> void Script::Return<double>(double value) { lua_pushnumber(lua_state,value); } template<> void Script::Return<char>(char* value) { lua_pushstring(lua_state,value); } template<> void Script::Return<bool>(bool value) { lua_pushboolean(lua_state,value); }

लड़ाई कोड

यह कुछ करने का समय है!
मुख्य बदलें

 #include "Script.h" int main() { return 0; }

हम संकलन करते हैं। अब आप हमारी कक्षा का परीक्षण शुरू कर सकते हैं

याद रखें, मैंने लिखने का कार्य करने का वादा किया था? :)
Main.cpp को संशोधित करें

 #include "Script.h" //   _getch() #include <conio.h> //   Script script; //  Write   int Write(lua_State*) { //          for(int i = 1; i < script.GetArgumentCount()+1; i++) cout << script.GetArgument<char*>(i); //       _getch(); return 0; } int main() { script.Create(); //      ,    script.RegisterConstant<lua_cfunction>(Write,"Write"); script.DoFile("script.lua"); script.Close(); }

और प्रोजेक्ट के साथ फ़ोल्डर में, script.lua फ़ाइल बनाएं

 Write(1,2,3,4)

हम प्रोजेक्ट को संकलित और चलाते हैं।

अब हम स्क्रिप्ट बदलते हैं

 for i = 1, 4 do Write(i, "\n", "Hier kommt die Sonne", "\n") end

अब प्रोग्राम 2 लाइनों को प्रत्येक ("\ n" - एक नई लाइन का निर्माण करेगा), एंटर के दबाए जाने के लिए प्रतीक्षा करें, और आउटपुट लाइनें फिर से।

लिपियों के साथ प्रयोग!

यहाँ कार्यों के साथ एक उदाहरण main.cpp है और एक script.lua है

 #include "Script.h" #include <conio.h> #include <Windows.h> #include <time.h> Script script; int Write(lua_State*) { //          for(int i = 1; i < script.GetArgumentCount()+1; i++) cout << script.GetArgument<char*>(i); cout << "\n"; return 0; } int GetString(lua_State*) { //     cin   ,   Script char* str = ""; cin >> str; script.Return<char*>(str); //  !    1  -> return 1 return 1; } int Message(lua_State*) { //    MessageBox  Windows.h // ,    -        :) char* msg = script.GetArgument<char*>(1); MessageBox(0,msg,"",MB_OK); return 0; } int GetTwoRandomNumbers(lua_State*) { //      1000 srand(time(NULL)); for(int i = 0; i < 2; i++) script.Return<int>(rand()%1000); //  2  return 2; } int GetLotOfRandomNumbers(lua_State*) { //      1000 srand(time(NULL)); for(int i = 0; i < script.GetArgument<int>(1); i++) script.Return<int>(rand()%1000); //   ,     return script.GetArgument<int>(1); } int main() { script.Create(); script.RegisterConstant<lua_CFunction>(Write,"Write"); script.RegisterConstant<lua_CFunction>(GetString,"GetString"); script.RegisterConstant<lua_CFunction>(Message,"Message"); script.RegisterConstant<lua_CFunction>(GetTwoRandomNumbers,"Rand1"); script.RegisterConstant<lua_CFunction>(GetLotOfRandomNumbers,"Rand2"); script.Array(); script.RegisterConstantArray<int>(1,1); script.RegisterConstantArray<int>(2,2); script.RegisterConstantArray<int>(3,3); script.RegisterConstantArray<int>(4,4); script.RegisterArray("mass"); script.DoFile("script.lua"); script.Close(); //    _getch(); }

 for i = 1, 4 do Write(i, "\n", "Hier kommt die Sonne", "\n") end Write(2*100-1) Message("!") a, b = Rand1() Write(a, "\n", b, "\n") Write(Rand1(), "\n") a, b, c, d = Rand2(4) Write(a, "\n", b, "\n", c, "\n", d, "\n") return 1

उपयोगी टिप्स

स्क्रिप्ट वर्ग के लिए, यह मायने नहीं रखता कि स्क्रिप्ट किस विस्तार में है, यहाँ तक कि .txt, यहाँ तक कि .lua, यहाँ तक कि .bmp में भी, .lua, YaP LP के कई संपादकों द्वारा खोला जाता है।
Lua कोड संपादकों का उपयोग करें, कोड लिखना बहुत मुश्किल है, आप अंत, करना, या कुछ और लिखना भूल सकते हैं। लुआ लिपि में त्रुटि के कारण प्रोग्राम क्रैश नहीं होगा, लेकिन बस कोड निष्पादित नहीं करेगा
जितना आप सोच सकते हैं उससे अधिक लचीला हो सकता है। उदाहरण के लिए, संख्याओं को स्वतंत्र रूप से स्ट्रिंग्स में परिवर्तित किया जाता है; यदि आप किसी फ़ंक्शन में 100 पैरामीटर पास करते हैं, और यह केवल C ++ में पहले 2 को पढ़ता है, तो प्रोग्राम क्रैश नहीं होगा। ऐसी और भी कई धारणाएँ हैं।

क्यू एंड ए

प्रश्न: हम लुआ स्टेट का उपयोग क्यों नहीं करते हैं जो प्रत्येक समान फ़ंक्शन में है - int foo (lua_State * L)?
उत्तर: पूरे कार्यक्रम के लिए, हम स्क्रिप्ट में केवल एक राज्य का उपयोग करते हैं, जहां हम फ़ंक्शन रजिस्टर करते हैं, इसे इनिशियलाइज़ करते हैं और अन्य काम करते हैं। इसके अलावा, यह बस एक पूरी कक्षा लिखने के लिए लाभहीन होगा और फिर से lua_State को ईमानदारी से lua_pushboolean और अन्य फ़ंक्शन के माध्यम से संदर्भित करेगा।

Script.h और Script.cpp की पूरी सूची

Script.h

 #ifndef _SCRIPT_H_ #define _SCRIPT_H_ #pragma comment(lib,"lua.lib") extern "C" { #include <lua.h> #include <lualib.h> #include <lauxlib.h> } class Script { private: lua_State *lua_state; public: void Create(); void Close(); int DoFile(char* ScriptFileName); template<class t> void RegisterConstant(T value, char* constantname); void Array(); template<class t> void RegisterConstantArray(T value, int index); void RegisterArray(char* arrayname); int GetArgumentCount(); template<class t> T GetArgument(int index); template<class t> void Return(T value); }; #endif

मैंने कंसोल के साथ काम करने के लिए हटा दिया

Script.cpp

 #include "Script.h" void Script::Create() { lua_state = luaL_newstate(); static const luaL_Reg lualibs[] = { {"base", luaopen_base}, {"io", luaopen_io}, {NULL, NULL} }; for(const luaL_Reg *lib = lualibs; lib->func != NULL; lib++) { luaL_requiref(lua_state, lib->name, lib->func, 1); lua_settop(lua_state, 0); } } void Script::Close() { lua_close(lua_state); } int Script::DoFile(char* ScriptFileName) { luaL_dofile(lua_state,ScriptFileName); return lua_tointeger(lua_state, lua_gettop(lua_state)); } template<> void Script::RegisterConstant<int>(int value, char* constantname) { lua_pushinteger(lua_state, value); lua_setglobal(lua_state,constantname); } template<> void Script::RegisterConstant<double>(double value, char* constantname) { lua_pushnumber(lua_state, value); lua_setglobal(lua_state,constantname); } template<> void Script::RegisterConstant<char>(char* value, char* constantname) { lua_pushstring(lua_state, value); lua_setglobal(lua_state,constantname); } template<> void Script::RegisterConstant<bool>(bool value, char* constantname) { lua_pushboolean(lua_state, value); lua_setglobal(lua_state,constantname); } template<> void Script::RegisterConstant<lua_cfunction>(int(*value)(lua_State*), char* constantname) { lua_pushcfunction(lua_state, value); lua_setglobal(lua_state,constantname); } void Script::Array() { lua_createtable(lua_state, 2, 0); } template<> void Script::RegisterConstantArray<int>(int value, int index) { lua_pushnumber(lua_state, index); lua_pushinteger(lua_state, value); lua_settable(lua_state, -3); } template<> void Script::RegisterConstantArray<double>(double value, int index) { lua_pushnumber(lua_state, index); lua_pushnumber(lua_state, value); lua_settable(lua_state, -3); } template<> void Script::RegisterConstantArray<char>(char* value, int index) { lua_pushnumber(lua_state, index); lua_pushstring(lua_state, value); lua_settable(lua_state, -3); } template<> void Script::RegisterConstantArray<bool>(bool value, int index) { lua_pushnumber(lua_state, index); lua_pushboolean(lua_state, value); lua_settable(lua_state, -3); } template<> void Script::RegisterConstantArray<lua_cfunction>(lua_CFunction value, int index) { lua_pushnumber(lua_state, index); lua_pushcfunction(lua_state, value); lua_settable(lua_state, -3); } void Script::RegisterArray(char* arrayname) { lua_setglobal(lua_state, arrayname); } int Script::GetArgumentCount() { return lua_gettop(lua_state); } template<> int Script::GetArgument<int>(int index) { return lua_tointeger(lua_state,index); } template<> double Script::GetArgument<double>(int index) { return lua_tonumber(lua_state,index); } template<> char* Script::GetArgument<char>(int index) { return (char*)lua_tostring(lua_state,index); } template<> bool Script::GetArgument<bool>(int index) { return lua_toboolean(lua_state,index); } template<> void Script::Return<int>(int value) { lua_pushinteger(lua_state,value); } template<> void Script::Return<double>(double value) { lua_pushnumber(lua_state,value); } template<> void Script::Return<char>(char* value) { lua_pushstring(lua_state,value); } template<> void Script::Return<bool>(bool value) { lua_pushboolean(lua_state,value); }

Lib के साथ भंडार और इसमें शामिल हैं: https://github.com/Izaron/LuaForHabr

मुझे सभी प्रश्न पीएम को भेजें, या इस विषय पर, या यदि आप भाग्यशाली नहीं हैं कि हेबेरा में पंजीकृत होना चाहते हैं - ईमेल izarizar@mail.ru पर

स्क्रिप्ट क्या हैं और उन्हें खाने के लिए क्या है - लुआ और सी ++

आपको क्या जानने की जरूरत है?

क्यों एक .cpp फ़ाइल में गेम डायलॉग लिखना एक बड़ी गलती थी

समस्या हल करना

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

मैं तैयार हूँ!

लड़ाई कोड

उपयोगी टिप्स

क्यू एंड ए

More articles: