📈 🖖🏼 🤛🏿 लिटिल ब्रेव अर्कानॉइड (भाग 2

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

YAML अधिक संक्षिप्त है, और आज, हम सीखेंगे कि इसका उपयोग कैसे करें।

शुरुआत करने के लिए, हम तय करेंगे कि हमें YAML की आवश्यकता क्यों है। मेरा मानना है कि, अन्य बातों के अलावा, इसमें स्तरों के विवरण को संग्रहीत करना सुविधाजनक होगा, उदाहरण के लिए, इस रूप में:

level.json

{ board: { width: 320 }, types: { odd: { inner_color: 0xffffff00, outer_color: 0xff50ff00, width: 40, height: 20 }, even: { inner_color: 0xff1010ff, outer_color: 0xffffffff, width: 40, height: 20 } }, level: [ { type: odd, x: 50, y: 30 }, { type: even, x: 94, y: 30 }, { type: odd, x: 138, y: 30 }, { type: even, x: 182, y: 30 }, { type: odd, x: 226, y: 30 }, { type: even, x: 270, y: 30 }, { type: even, x: 50, y: 54 }, { type: odd, x: 94, y: 54 }, { type: even, x: 138, y: 54 }, { type: odd, x: 182, y: 54 }, { type: even, x: 226, y: 54 }, { type: odd, x: 270, y: 54 }, { type: odd, x: 50, y: 78 }, { type: even, x: 94, y: 78 }, { type: odd, x: 138, y: 78 }, { type: even, x: 182, y: 78 }, { type: odd, x: 226, y: 78 }, { type: even, x: 270, y: 78 }, { type: even, x: 50, y: 102 }, { type: odd, x: 94, y: 102 }, { type: even, x: 138, y: 102 }, { type: odd, x: 182, y: 102 }, { type: even, x: 226, y: 102 }, { type: odd, x: 270, y: 102 } ] }

बस गुस्से में चिल्लाओ मत "उन्होंने हमें धोखा दिया!"। हाँ, यह JSON है । अच्छी खबर यह है कि यह YAML भी है। यह सिर्फ इतना है कि JSON YAML का सबसेट है और किसी JSON विवरण को YAML पार्सर द्वारा समस्या के बिना पार्स किया जाना चाहिए। JSON थोड़ा अधिक संश्लिष्ट रूप से मजबूत और थोड़ा कम संक्षिप्त है (लेकिन अभी भी XML की तुलना में अधिक संक्षिप्त है)।

जैसा कि shokoladko ने सही टिप्पणी की है, नीचे दी गई टिप्पणियों में, YAML संस्करण संपादन के लिए काफी छोटा और अधिक सुविधाजनक होगा (सूची आइटमों को अलग करने वाले अल्पविरामों की अनुपस्थिति के कारण)। यहाँ यह कैसा दिखेगा:

level.yaml

 board: width: 320 types: odd: inner_color: 0xffffff00 outer_color: 0xff50ff00 width: 40 height: 20 even: inner_color: 0xff1010ff outer_color: 0xffffffff width: 40 height: 20 level: - type: odd x: 50 y: 30 - type: even x: 94 y: 30 - type: odd x: 138 y: 30 - type: even x: 182 y: 30 - type: odd x: 226 y: 30 - type: even x: 270 y: 30 - type: even x: 50 y: 54 - type: odd x: 94 y: 54 - type: even x: 138 y: 54 - type: odd x: 182 y: 54 - type: even x: 226 y: 54 - type: odd x: 270 y: 54 - type: odd x: 50 y: 78 - type: even x: 94 y: 78 - type: odd x: 138 y: 78 - type: even x: 182 y: 78 - type: odd x: 226 y: 78 - type: even x: 270 y: 78 - type: even x: 50 y: 102 - type: odd x: 94 y: 102 - type: even x: 138 y: 102 - type: odd x: 182 y: 102 - type: even x: 226 y: 102 - type: odd x: 270 y: 102

इसके अलावा, YAML संबंधपरक डेटा का समर्थन करता है। विवरण में 'और' वर्ण का उपयोग करके, एक "लंगर" को परिभाषित किया जा सकता है, जिसे बाद में "उपनाम" ('*' चरित्र) द्वारा किए गए प्रतिस्थापन प्रदर्शन करने के लिए इस्तेमाल किया जा सकता है। इस तरह, पुनरावर्ती संरचनाएं व्यक्त की जा सकती हैं।

लेकिन पर्याप्त सिद्धांत, चलो व्यापार के लिए नीचे उतरो। हम YAML को पार्स करने के लिए इंटरनेट पर किसी भी लाइब्रेरी को ढूंढते हैं और इसे अपने प्रोजेक्ट में एम्बेड करने का प्रयास करते हैं। वैसे, हमने जो पुस्तकालय चुना था, वह किरिल सिमोनोव द्वारा विकसित किया गया था और इसे एमआईटी लाइसेंस के तहत स्वतंत्र रूप से वितरित किया गया है (जो कि पुस्तकालय विवरण पृष्ठ के कॉपीराइट अनुभाग में पाया जा सकता है)।

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

yaml.mkf

 includepath h includepath source files { (h) yaml.h config.h (source) yaml_private.h api.c dumper.c emitter.c loader.c parser.c reader.c scanner.c writer.c }

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

चलो इसे करते हैं:

arcanoid.mkb

 #!/usr/bin/env mkb options { module_path="../yaml" } subprojects { iwgl yaml } includepath { ./source/Main ./source/Model } files { [Main] (source/Main) Main.cpp Main.h Quads.cpp Quads.h Desktop.cpp Desktop.h IO.cpp IO.h [Model] (source/Model) Board.cpp Board.h Bricks.cpp Bricks.h Ball.cpp Ball.h [Data] (data) } assets { (data) level.json (data-ram/data-gles1, data/data-gles1) }

अब, YAML मॉड्यूल परियोजना से जुड़ा हुआ है और हमें यह जानने की आवश्यकता है कि इससे प्राप्त डेटा को कैसे संसाधित किया जाए। बोर्ड में कई बदलाव करना काफी है:

Board.h

 #ifndef _BOARD_H_ #define _BOARD_H_ #include <yaml.h> #include <vector> #include <String> #include "Bricks.h" #include "Ball.h" #define MAX_NAME_SZ 100 using namespace std; enum EBrickMask { ebmX = 0x01, ebmY = 0x02, ebmComplete = 0x03, ebmWidth = 0x04, ebmHeight = 0x08, ebmIColor = 0x10, ebmOColor = 0x20 }; class Board { private: struct Type { Type(const char* s, const char* n, const char* v): s(s), n(n), v(v) {} Type(const Type& p): s(ps), n(pn), v(pv) {} string s, n, v; }; Bricks bricks; Ball ball; yaml_parser_t parser; yaml_event_t event; vector<string> scopes; vector<Type> types; char currName[MAX_NAME_SZ]; int brickMask; int brickX, brickY, brickW, brickH, brickIC, brickOC; bool isTypeScope; void load(); void clear(); void notify(); const char* getScopeName(); void setProperty(const char* scope, const char* name, const char* value); void closeTag(const char* scope); int fromNum(const char* s); public: Board(): scopes(), types() {} void init(); void refresh(); void update() {} typedef vector<string>::iterator SIter; typedef vector<Type>::iterator TIter; }; #endif // _BOARD_H_

Board.cpp

 #include "Board.h" #include "Desktop.h" const char* BOARD_SCOPE = "board"; const char* LEVEL_SCOPE = "level"; const char* TYPE_SCOPE = "types"; const char* TYPE_PROPERTY = "type"; const char* WIDTH_PROPERTY = "width"; const char* HEIGHT_PROPERTY = "height"; const char* IC_PROPERTY = "inner_color"; const char* OC_PROPERTY = "outer_color"; const char* X_PROPERTY = "x"; const char* Y_PROPERTY = "y"; void Board::init() { load(); ball.init(); } void Board::clear() { bricks.clear(); scopes.clear(); memset(currName, 0, sizeof(currName)); types.clear(); } void Board::load() { clear(); yaml_parser_initialize(&parser); FILE *input = fopen("level.json", "rb"); yaml_parser_set_input_file(&parser, input); int done = 0; while (!done) { if (!yaml_parser_parse(&parser, &event)) { break; } notify(); done = (event.type == YAML_STREAM_END_EVENT); yaml_event_delete(&event); } yaml_parser_delete(&parser); fclose(input); } void Board::notify() { switch (event.type) { case YAML_MAPPING_START_EVENT: case YAML_SEQUENCE_START_EVENT: scopes.push_back(currName); memset(currName, 0, sizeof(currName)); break; case YAML_MAPPING_END_EVENT: closeTag(getScopeName()); case YAML_SEQUENCE_END_EVENT: scopes.pop_back(); break; case YAML_SCALAR_EVENT: if (currName[0] == 0) { strncpy(currName, (const char*)event.data.scalar.value, sizeof(currName)-1); break; } setProperty(getScopeName(), currName, (const char*)event.data.scalar.value); memset(currName, 0, sizeof(currName)); break; default: break; } } const char* Board::getScopeName() { const char* r = NULL; isTypeScope = false; for (SIter p = scopes.begin(); p !=scopes.end(); ++p) { if (!(*p).empty()) { if (strcmp((*p).c_str(), TYPE_SCOPE) == 0) { isTypeScope = true; continue; } r = (*p).c_str(); } } return r; } int Board::fromNum(const char* s) { int r = 0; int x = 10; for (size_t i = 0; i < strlen(s); i++) { switch (s[i]) { case 'x': case 'X': x = 16; break; case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': x = 16; r *= x; r += s[i] - 'a' + 10; break; case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': x = 16; r *= x; r += s[i] - 'A' + 10; break; default: r *= x; r += s[i] - '0'; break; } } return r; } void Board::setProperty(const char* scope, const char* name, const char* value) { if (scope == NULL) return; if (isTypeScope) { types.push_back(Type(scope, name, value)); return; } if (strcmp(scope, BOARD_SCOPE) == 0) { if (strcmp(name, WIDTH_PROPERTY) == 0) { desktop.setVSize(fromNum(value)); } } if (strcmp(scope, LEVEL_SCOPE) == 0) { if (strcmp(name, TYPE_PROPERTY) == 0) { for (TIter p = types.begin(); p != types.end(); ++p) { if (strcmp(value, p->s.c_str()) == 0) { setProperty(scope, p->n.c_str(), p->v.c_str()); } } } if (strcmp(name, X_PROPERTY) == 0) { brickMask |= ebmX; brickX = fromNum(value); } if (strcmp(name, Y_PROPERTY) == 0) { brickMask |= ebmY; brickY = fromNum(value); } if (strcmp(name, WIDTH_PROPERTY) == 0) { brickMask |= ebmWidth; brickW = fromNum(value); } if (strcmp(name, HEIGHT_PROPERTY) == 0) { brickMask |= ebmHeight; brickH = fromNum(value); } if (strcmp(name, IC_PROPERTY) == 0) { brickMask |= ebmIColor; brickIC = fromNum(value); } if (strcmp(name, OC_PROPERTY) == 0) { brickMask |= ebmOColor; brickOC = fromNum(value); } } } void Board::closeTag(const char* scope) { if (scope == NULL) return; if (strcmp(scope, LEVEL_SCOPE) == 0) { if ((brickMask & ebmComplete) == ebmComplete) { Bricks::SBrick b(desktop.toRSize(brickX), desktop.toRSize(brickY)); if ((brickMask & ebmWidth) != 0) { b.hw = desktop.toRSize(brickW) / 2; } if ((brickMask & ebmHeight) != 0) { b.hh = desktop.toRSize(brickH) / 2; } if ((brickMask & ebmIColor) != 0) { b.ic = brickIC; } if ((brickMask & ebmOColor) != 0) { b.oc = brickOC; } bricks.add(b); } brickMask = 0; } } void Board::refresh() { bricks.refresh(); ball.refresh(); }

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

"बोर्ड" अनुभाग में, हम बोर्ड की चौड़ाई का वर्णन करते हैं। अन्य सभी आकार, स्तर के विवरण में, इसके सापेक्ष परिभाषित किए गए हैं। मैं इस तथ्य पर आपका ध्यान आकर्षित करता हूं कि हमें स्तर विवरण में बोर्ड की ऊंचाई निर्धारित करने की आवश्यकता नहीं है। ऊर्ध्वाधर आयाम क्षैतिज आयामों के समान अनुपात में पुनर्गणना किए जाते हैं। इस प्रकार, हम यह प्राप्त करते हैं कि स्क्रीन की चौड़ाई और ऊंचाई के विभिन्न अनुपातों के साथ उपकरणों पर स्तर लगभग समान दिखता है (अंतर किसी भी स्तर पर उपलब्ध खाली क्षेत्र में "खो गया" है)।

निष्पादन पर कार्यक्रम चलाना, हम देखेंगे कि हमारा डेटा सफलतापूर्वक लोड किया गया है:

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

 [S3E] SysGlesVersion=1 DispFixRot=FixedPortrait DataDirIsRAM=1

वह सब है। YAML के साथ काम करने के लिए मॉड्यूल GitHub पर पोस्ट किया गया है ।

अगले लेख में, हम सीखेंगे कि बॉक्स 2 डी के साथ कैसे काम किया जाए।

लिटिल ब्रेव अर्कानॉइड (भाग 2 - YAML)

More articles: