प्रलयकाल के काले दिन आगे: स्थैतिक विश्लेषण और रोगविषयक खेल

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

असामान्य खेलों की खोज करते हुए, मैं कैटैकलीम डार्क डेज अहेड पर ठोकर खाई, जो कि ब्लैक बैकग्राउंड पर व्यवस्थित विभिन्न रंगों के ASCII वर्णों के आधार पर अपने ग्राफिक्स की बदौलत अन्य खेलों में शामिल है।

एक बात जो आपको इस और अन्य समान खेलों के बारे में हैरान करती है कि उनमें कितनी कार्यक्षमता है। उदाहरण के लिए, कैटकैली में विशेष रूप से, आप दर्जनों मापदंडों, लक्षणों और प्रारंभिक परिदृश्यों के कारण कुछ गाइडों को Google से आग्रह किए बिना चरित्र का निर्माण नहीं कर सकते हैं, जो कि पूरे खेल में होने वाली घटनाओं के कई रूपों का उल्लेख नहीं करते हैं।

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

बहुत सारे गेम पीवीएस-स्टूडियो के साथ पहले ही चेक किए जा चुके हैं। आप हमारे लेख " वीडियो गेम डेवलपमेंट में स्टेटिक एनालिसिस: टॉप 10 सॉफ्टवेयर बग्स " में कुछ उदाहरण पा सकते हैं।

तर्क

उदाहरण 1:

यह उदाहरण क्लासिक कॉपी-पेस्ट त्रुटि दिखाता है।

V501 बाईं और 'के दाईं ओर समान उप-अभिव्यक्तियाँ हैं' || ऑपरेटर: rng (2, 7) <abs (z) || rng (2, 7) <abs (z) ओवरमैप। 1503

bool overmap::generate_sub( const int z ) { .... if( rng( 2, 7 ) < abs( z ) || rng( 2, 7 ) < abs( z ) ) { .... } .... } 

एक ही स्थिति को दो बार जांचा जाता है। प्रोग्रामर ने अभिव्यक्ति की प्रतिलिपि बनाई लेकिन प्रतिलिपि को संशोधित करना भूल गया। मुझे यकीन नहीं है कि यह एक महत्वपूर्ण बग है, लेकिन तथ्य यह है कि चेक काम नहीं करता है जैसा कि यह था।

इसी तरह की एक और त्रुटि:

• V501 समान उप-अभिव्यक्तियाँ 'one_in (100000 / to_turns <int> (dur))' बाईं ओर और '&&' ऑपरेटर के दाईं ओर होती हैं। player_hardcoded_effects.cpp 547

उदाहरण 2:

V728 एक अत्यधिक जाँच को सरल बनाया जा सकता है। द '(A && B) || ((A &&! B) 'अभिव्यक्ति' बूल (ए) == बूल (बी) 'अभिव्यक्ति के बराबर है। इन्वेंट्री_यू.सी .पीसी 199

 bool inventory_selector_preset::sort_compare( .... ) const { .... const bool left_fav = g->u.inv.assigned.count( lhs.location->invlet ); const bool right_fav = g->u.inv.assigned.count( rhs.location->invlet ); if( ( left_fav && right_fav ) || ( !left_fav && !right_fav ) ) { return .... } .... } 

यह स्थिति तार्किक रूप से सही है, लेकिन यह अतिरंजित है। जिसने भी इस कोड को लिखा है, उन्हें अपने साथी प्रोग्रामरों पर दया करनी चाहिए जो इसे बनाए रखेंगे। इसे सरल रूप में फिर से लिखा जा सकता है: यदि (बायां_फैव == दायां_फैव) ।

इसी तरह की एक और त्रुटि:

• V728 एक अत्यधिक जाँच को सरल बनाया जा सकता है। द '(A &&! B) || (ए! और बी) अभिव्यक्ति 'बूल (ए) के बराबर है! = बूल (बी)' अभिव्यक्ति। iuse_actor.cpp 2653

पाचन मैं

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

माइक्रो अनुकूलन

उदाहरण 3:

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

V801 प्रदर्शन में कमी। संदर्भ के रूप में दूसरे फ़ंक्शन तर्क को फिर से परिभाषित करना बेहतर है। 'Const ... टाइप करें' की जगह 'const ... & टाइप' पर विचार करें। map.cpp 4644

 template <typename Stack> std::list<item> use_amount_stack( Stack stack, const itype_id type ) { std::list<item> ret; for( auto a = stack.begin(); a != stack.end() && quantity > 0; ) { if( a->use_amount( type, ret ) ) { a = stack.erase( a ); } else { ++a; } } return ret; } 

इस कोड में, itype_id वास्तव में एक प्रच्छन्न std :: string है । चूंकि तर्क को एक निरंतर के रूप में वैसे भी पारित किया जाता है, जिसका अर्थ है कि यह अपरिवर्तनीय है, बस चर के संदर्भ में गुजरने से प्रदर्शन को बढ़ाने और कम्प्यूटेशनल संसाधनों को कॉपी ऑपरेशन से बचने से बचाने में मदद मिलेगी। और भले ही स्ट्रिंग एक लंबा होने की संभावना नहीं है, हर बार अच्छे कारण के बिना इसे कॉपी करना एक बुरा विचार है - सभी अधिक इसलिए क्योंकि इस फ़ंक्शन को विभिन्न कॉलर्स द्वारा बुलाया जाता है, जो बदले में, बाहर से भी टाइप करते हैं और होते हैं इसे कॉपी करने के लिए।

इसी तरह की समस्याएं:

• V801 प्रदर्शन में कमी। एक संदर्भ के रूप में तीसरे फ़ंक्शन तर्क को फिर से परिभाषित करना बेहतर है। 'Const ... evt_filter' को 'const ... & evt_filter' से बदलने पर विचार करें। input.cpp 691
• V801 प्रदर्शन में कमी। एक संदर्भ के रूप में पांचवें फ़ंक्शन तर्क को फिर से परिभाषित करना बेहतर है। 'Const ... कलर' को 'const ... और कलर' से बदलने पर विचार करें। आउटपुट। ह 207
• विश्लेषक ने इस प्रकार की कुल 32 चेतावनियाँ जारी कीं।

उदाहरण 4:

V813 प्रदर्शन में कमी। 'Str' तर्क को संभवतः एक निरंतर संदर्भ के रूप में प्रस्तुत किया जाना चाहिए। catacharset.cpp 256

 std::string base64_encode( std::string str ) { if( str.length() > 0 && str[0] == '#' ) { return str; } int input_length = str.length(); std::string encoded_data( output_length, '\0' ); .... for( int i = 0, j = 0; i < input_length; ) { .... } for( int i = 0; i < mod_table[input_length % 3]; i++ ) { encoded_data[output_length - 1 - i] = '='; } return "#" + encoded_data; } 

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

यह चेतावनी अकेले भी नहीं आई थी; इस प्रकार की चेतावनियों की कुल संख्या 26 है।


इसी तरह की समस्याएं:

• V813 प्रदर्शन में कमी। 'संदेश' तर्क को संभवतः एक निरंतर संदर्भ के रूप में प्रस्तुत किया जाना चाहिए। json.cpp 1452
• V813 प्रदर्शन में कमी। 'S' तर्क को संभवतः एक निरंतर संदर्भ के रूप में प्रस्तुत किया जाना चाहिए। catacharset.cpp 218
• और इसी तरह…

पाचन ii

कुछ क्लासिक रॉगुलाइक गेम अभी भी सक्रिय विकास में हैं। यदि आप Cataclysm DDA या NetHack के GitHub रिपॉजिटरी की जांच करते हैं, तो आप देखेंगे कि हर दिन परिवर्तन प्रस्तुत किए जाते हैं। नेटहैक वास्तव में सबसे पुराना गेम है जिसे अभी भी विकसित किया जा रहा है: यह जुलाई 1987 में जारी किया गया था, और अंतिम संस्करण 2018 की तारीख है।

बौना किले सबसे लोकप्रिय में से एक है - हालांकि छोटी - शैली के खेल। विकास 2002 में शुरू हुआ और पहला संस्करण 2006 में जारी किया गया था। इसका आदर्श वाक्य "हारना मजेदार है" इस तथ्य को दर्शाता है कि इस खेल में जीतना असंभव है। 2007 में, एएससीआईआई गेम साइट पर प्रतिवर्ष आयोजित होने वाले मतदान द्वारा बौने किले को "वर्ष का सर्वश्रेष्ठ रोगविषयक खेल" प्रदान किया गया।


वैसे, प्रशंसकों को यह जानकर खुशी हो सकती है कि बौना किले दो अनुभवी मॉडर्स द्वारा जोड़े गए 32-बिट ग्राफिक्स के साथ स्टीम में आ रहे हैं। प्रीमियम-संस्करण को अतिरिक्त संगीत ट्रैक और स्टीम वर्कशॉप समर्थन भी मिलेगा। भुगतान की गई प्रतियों के स्वामी यदि चाहें तो पुराने ASCII ग्राफिक्स पर स्विच कर सकेंगे। अधिक ।

असाइनमेंट ऑपरेटर को ओवरराइड करना

उदाहरण 5, 6:

यहाँ दिलचस्प चेतावनियों की एक जोड़ी है।

V690 'JsonObject' क्लास एक कॉपी कंस्ट्रक्टर को लागू करता है, लेकिन इसमें '=' ​​ऑपरेटर की कमी होती है। ऐसी कक्षा का उपयोग करना खतरनाक है। json.h 647

 class JsonObject { private: .... JsonIn *jsin; .... public: JsonObject( JsonIn &jsin ); JsonObject( const JsonObject &jsobj ); JsonObject() : positions(), start( 0 ), end( 0 ), jsin( NULL ) {} ~JsonObject() { finish(); } void finish(); // moves the stream to the end of the object .... void JsonObject::finish() { .... } .... } 

इस वर्ग में एक कॉपी कंस्ट्रक्टर और एक विध्वंसक है लेकिन असाइनमेंट ऑपरेटर को ओवरराइड नहीं करता है। समस्या यह है कि स्वचालित रूप से उत्पन्न असाइनमेंट ऑपरेटर केवल JsonIn को पॉइंटर असाइन कर सकता है। नतीजतन, वर्ग JsonObject की दोनों वस्तुएं एक ही JsonIn की ओर इशारा करती हैं । मैं निश्चित रूप से यह नहीं कह सकता कि यदि वर्तमान संस्करण में ऐसी स्थिति हो सकती है, लेकिन कोई न कोई एक दिन इस जाल में जरूर पड़ेगा।

अगली कक्षा में इसी तरह की समस्या है।

V690 'JsonArray' क्लास एक कॉपी कंस्ट्रक्टर को लागू करता है, लेकिन '=' ऑपरेटर की कमी है। ऐसी कक्षा का उपयोग करना खतरनाक है। json.h 820

 class JsonArray { private: .... JsonIn *jsin; .... public: JsonArray( JsonIn &jsin ); JsonArray( const JsonArray &jsarr ); JsonArray() : positions(), ...., jsin( NULL ) {}; ~JsonArray() { finish(); } void finish(); // move the stream position to the end of the array void JsonArray::finish() { .... } } 

एक जटिल वर्ग में असाइनमेंट ऑपरेटर को ओवरराइड नहीं करने का खतरा " द लॉ ऑफ द बिग टू " लेख में विस्तार से बताया गया है।

उदाहरण 7, 8:

ये दोनों असाइनमेंट ऑपरेटर ओवरराइडिंग से भी निपटते हैं, लेकिन इस बार इसके विशिष्ट कार्यान्वयन हैं।

V794 असाइनमेंट ऑपरेटर को 'यह == & अन्य' के मामले से संरक्षित किया जाना चाहिए। मटका_ असामान्य.ह 49

 class StringRef { public: .... private: friend struct StringRefTestAccess; char const* m_start; size_type m_size; char* m_data = nullptr; .... auto operator = ( StringRef const &other ) noexcept -> StringRef& { delete[] m_data; m_data = nullptr; m_start = other.m_start; m_size = other.m_size; return *this; } 

इस कार्यान्वयन में संभावित स्व-असाइनमेंट के खिलाफ कोई सुरक्षा नहीं है, जो असुरक्षित अभ्यास है। यही है, इस ऑपरेटर के लिए यह संदर्भ * पास करने से स्मृति रिसाव हो सकता है।

यहाँ एक गलत तरीके से ओवरराइड असाइनमेंट ऑपरेटर का एक समान उदाहरण एक अजीबोगरीब साइड इफेक्ट के साथ है:

V794 असाइनमेंट ऑपरेटर को 'यह == & rhs' के मामले से सुरक्षित किया जाना चाहिए। player_activity.cpp 38

 player_activity &player_activity::operator=( const player_activity &rhs ) { type = rhs.type; .... targets.clear(); targets.reserve( rhs.targets.size() ); std::transform( rhs.targets.begin(), rhs.targets.end(), std::back_inserter( targets ), []( const item_location & e ) { return e.clone(); } ); return *this; } 

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

पाचन iii

2008 में, roguelikes को महाकाव्य शीर्षक "बर्लिन इंटरप्रिटेशन" के तहत एक औपचारिक परिभाषा भी मिली। इसके अनुसार, ऐसे सभी खेल निम्नलिखित तत्वों को साझा करते हैं:

• बेतरतीब ढंग से उत्पन्न दुनिया, जो पुनरावृत्ति बढ़ाती है;
• Permadeath: यदि आपका चरित्र मर जाता है, तो वे अच्छे के लिए मर जाते हैं, और उनके सभी आइटम खो जाते हैं;
• टर्न-आधारित गेमप्ले: कोई भी परिवर्तन खिलाड़ी के कार्यों के साथ ही होता है; समय का प्रवाह तब तक निलंबित रहता है जब तक खिलाड़ी कोई क्रिया नहीं करता;
• उत्तरजीविता: संसाधन बहुत कम हैं।

अंत में, roguelikes की सबसे महत्वपूर्ण विशेषता मुख्य रूप से दुनिया की खोज, वस्तुओं के लिए नए उपयोगों और कालकोठरी रेंगने पर ध्यान केंद्रित कर रही है।

यह आप के लिए कैटेकलीस्स डीडीए में एक सामान्य स्थिति है कि आप हड्डी, भूखे, प्यासे, और अपने सभी पैरों को छह टेंकलेस के साथ बदलकर, हड्डी को जमी हुई, समाप्त करने के लिए चरित्र को समाप्त करते हैं।

उस बात का विवरण

उदाहरण 9:

V1028 संभावित अतिप्रवाह। 'Size_t' प्रकार के 'प्रारंभ + बड़े' ऑपरेटर के कास्टिंग ऑपरेंड पर विचार करें, परिणाम नहीं। worldfactory.cpp 638

 void worldfactory::draw_mod_list( int &start, .... ) { .... int larger = ....; unsigned int iNum = ....; .... for( .... ) { if( iNum >= static_cast<size_t>( start ) && iNum < static_cast<size_t>( start + larger ) ) { .... } .... } .... } 

ऐसा लगता है कि प्रोग्रामर एक अतिप्रवाह के खिलाफ सावधानी बरतना चाहता था। हालाँकि, राशि के प्रकार को बढ़ावा देने से कोई फर्क नहीं पड़ेगा क्योंकि इससे पहले कि अतिप्रवाह हो जाएगा, मूल्यों को जोड़ने के चरण में, और पदोन्नति एक अर्थहीन मूल्य पर किया जाएगा। इससे बचने के लिए, केवल एक तर्क को एक व्यापक प्रकार में डाला जाना चाहिए: (static_cast <size_t> (start) + +) ।

उदाहरण 10:

V530 फ़ंक्शन 'आकार' के रिटर्न मान का उपयोग करने की आवश्यकता है। worldfactory.cpp 1340

 bool worldfactory::world_need_lua_build( std::string world_name ) { #ifndef LUA .... #endif // Prevent unused var error when LUA and RELEASE enabled. world_name.size(); return false; } 

इस तरह के मामलों के लिए एक चाल है। यदि आप एक अप्रयुक्त चर के साथ समाप्त होते हैं और आप संकलक चेतावनी को दबाना चाहते हैं, तो बस उस चर पर तरीकों को कॉल करने के बजाय (शून्य) world_name लिखें।

उदाहरण 11:

V812 प्रदर्शन में कमी। 'गिनती' फ़ंक्शन का अप्रभावी उपयोग। यह संभवतः कॉल को 'खोज' फ़ंक्शन से बदल सकता है। खिलाी। ९ ६००

 bool player::read( int inventory_position, const bool continuous ) { .... player_activity activity; if( !continuous || !std::all_of( learners.begin(), learners.end(), [&]( std::pair<npc *, std::string> elem ) { return std::count( activity.values.begin(), activity.values.end(), elem.first->getID() ) != 0; } ) { .... } .... } 

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

उदाहरण 12:

इस बग को खोजना आसान है यदि आप चार प्रकार के बारे में एक मुश्किल विवरण जानते हैं।

V739 ईओएफ की तुलना 'चार' प्रकार के मूल्य से नहीं की जानी चाहिए। 'Ch' 'int' प्रकार का होना चाहिए। json.cpp 762

 void JsonIn::skip_separator() { signed char ch; .... if (ch == ',') { if( ate_separator ) { .... } .... } else if (ch == EOF) { .... } 

यह उन त्रुटियों में से एक है, जिन्हें आप आसानी से नहीं जान पाएंगे, जब तक कि आप यह नहीं जानते कि ईओएफ -1 के रूप में परिभाषित है। इसलिए, जब इसे टाइप किए गए चार्ट के चर के साथ तुलना किया जाता है, तो स्थिति लगभग हर मामले में झूठी का मूल्यांकन करती है। एकमात्र अपवाद चरित्र के साथ है जिसका कोड 0xFF (255) है। जब एक तुलना में उपयोग किया जाता है, तो यह -1 हो जाएगा, इस प्रकार स्थिति को सच कर देगा।

उदाहरण 13:

यह छोटा बग किसी दिन महत्वपूर्ण हो सकता है। अच्छे कारण हैं, आखिरकार, यह CWE की सूची में CWE-834 के रूप में पाया गया है। ध्यान दें कि परियोजना ने इस चेतावनी को पांच बार ट्रिगर किया है।

V663 अनंत लूप संभव है। लूप से टूटने के लिए 'Cin.eof ()' स्थिति अपर्याप्त है। सशर्त अभिव्यक्ति के लिए 'cin.fail ()' फ़ंक्शन कॉल जोड़ने पर विचार करें। क्रिया .pp 46

 void parse_keymap( std::istream &keymap_txt, .... ) { while( !keymap_txt.eof() ) { .... } } 

जैसा कि चेतावनी कहती है, फ़ाइल से पढ़ते समय ईओएफ की जांच करना पर्याप्त नहीं है - आपको सिने.फाइल () कॉल करके इनपुट विफलता के लिए भी जांच करनी होगी। चलो इसे सुरक्षित बनाने के लिए कोड को ठीक करें:

 while( !keymap_txt.eof() ) { if(keymap_txt.fail()) { keymap_txt.clear(); keymap_txt.ignore(numeric_limits<streamsize>::max(),'\n'); break; } .... } 

Keymap_txt.clear () का उद्देश्य एक त्रुटि पढ़ने के बाद स्ट्रीम पर त्रुटि स्थिति (ध्वज) को साफ़ करना है ताकि आप शेष पाठ को पढ़ सकें। पैरामीटर के साथ keymap_txt.ignore को कॉल करते हुए num_limits < स्ट्रीम > :: max () और newline वर्ण आपको स्ट्रिंग के शेष भाग को छोड़ने की अनुमति देता है।

पढ़ने को रोकने का एक बहुत सरल तरीका है:

 while( !keymap_txt ) { .... } 

जब तर्क के संदर्भ में रखा जाता है, तो धारा ईओएफ तक पहुंचने के लिए खुद को सही के बराबर मूल्य में बदल देगी।

पाचन iv

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

हालाँकि, roguelike और roguelite के बीच का अंतर कई बार इतना छोटा हो सकता है कि आप यह नहीं बता सकते कि गेम किस श्रेणी में आता है। कुछ लोगों का तर्क है कि बौना किले सख्त अर्थों में एक रॉगविलाइक नहीं है, जबकि अन्य का मानना ​​है कि डियाब्लो एक क्लासिक रूग्युलाइक गेम है।

निष्कर्ष

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


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