🚮 👩🏿‍🏫 👩🏽‍🤝‍👨🏾 VVVVVV ??? VVVVVV !!! :) 👨🏾‍🎨 ⏏️ 🍍

यदि आप इस पाठ को पढ़ते हैं, तो इसका मतलब है कि आपने या तो सोचा था कि लेख के शीर्षक के साथ कुछ गलत था, या आपने इसमें एक परिचित कंप्यूटर गेम का नाम देखा। वीवीवीवीवी एक इंडी प्लेटफ़ॉर्मर गेम है जिसने अपनी सुखद बाहरी सादगी और समान रूप से सुखद आंतरिक एकता के साथ कई खिलाड़ियों का दिल जीता है। कुछ दिनों पहले VVVVVV 10 साल का हो गया, और खेल के लेखक - टेरी कैवानघ ने इस छुट्टी को अपने स्रोत कोड के प्रकाशन के साथ मनाया। इसमें "स्वादिष्ट" क्या पाया जा सकता है? इस लेख में उत्तर पढ़ें।

परिचय

ओह, वीवीवीवीवीवी ... मुझे याद है कि रिलीज के कुछ समय बाद ही मैं कैसे भर गया था, और, पिक्सेल रेट्रो गेम्स का बहुत बड़ा प्रशंसक होने के नाते, मैंने खुशी से इसे अपने कंप्यूटर पर स्थापित किया। मुझे अपना पहला इंप्रेशन याद है: “और क्या यह सब है? बस वर्ग कमरे के आसपास चला? ”मैंने सोचा कि खेल के कुछ ही मिनटों के बाद। मुझे अभी तक नहीं पता था कि मुझे क्या इंतजार है। जैसे ही मैंने शुरुआती स्थान छोड़ा, मैंने खुद को एक छोटे लेकिन भ्रमित और अलंकृत द्वि-आयामी दुनिया में पाया जो मेरे लिए अज्ञात परिदृश्य और पिक्सेल कलाकृतियों से भरा था।

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

चलो खेल की सालगिरह के सम्मान में निर्धारित स्रोत कोड पर वापस जाएं।

फिलहाल, मैं सी ++ हूं - पीवीएस-स्टूडियो टीम में डेवलपर - सी, सी ++, सी # और जावा के लिए एक स्थिर कोड विश्लेषक। विकास के अलावा, हम अपने उत्पाद के प्रचार में भी लगे हुए हैं। हमारे लिए, ऐसा करने का एक सबसे अच्छा तरीका ओपन सोर्स प्रोजेक्ट्स की जाँच पर लेख लिखना है। हमारे पाठकों को प्रोग्रामिंग विषयों पर दिलचस्प लेख मिलते हैं, और हमें पीवीएस-स्टूडियो की क्षमताओं को स्पष्ट रूप से प्रदर्शित करने का अवसर मिलता है। इसलिए, जब मुझे स्रोत कोड VVVVVV के उद्घाटन के बारे में पता चला, तो मैं अभी पास नहीं हो सका।

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

विश्लेषक द्वारा जारी अलर्ट का अवलोकन

चेतावनी १

V512 ' स्प्रिंटफ ' फ़ंक्शन के कॉल से बफर 'फ़ाइल खोज' का ओवरफ़्लो हो जाएगा। FileSystemUtils.cpp 307

#define MAX_PATH 260 .... void PLATFORM_migrateSaveData(char *output) { char oldLocation[MAX_PATH]; char newLocation[MAX_PATH]; char oldDirectory[MAX_PATH]; char fileSearch[MAX_PATH]; .... /* Same place, different layout. */ strcpy(oldDirectory, output); sprintf(fileSearch, "%s\\*.vvvvvv", oldDirectory); .... }

जैसा कि आप देख सकते हैं, फ़ाइल खोज और पुरानी पंक्तियाँ समान आकार हैं: 260 वर्ण। स्ट्रिंग ओल्डडायरेक्ट्री की सामग्री को प्रतिस्थापित करने के बाद प्रारूपण स्ट्रिंग ( स्प्रिंटफ के लिए तीसरा तर्क) इस तरह दिखाई देगा:

 <i>_oldDirectory\*.vvvvvv</i>

यह स्ट्रिंग मूल ओल्डडायरेरी की तुलना में 9 वर्ण लंबी है। यह वर्णों का यह क्रम है जो आगे फ़ाइलस्क्रिप्‍ट में लिखा जाएगा। क्या होता है अगर पुराने अप्रत्यक्ष स्ट्रिंग 251 से अधिक है? परिणामी स्ट्रिंग फ़ाइलखोज की तुलना में अधिक लंबी हो सकती है, जिससे सरणी के बाहर लेखन हो जाएगा। रैम में किस तरह का डेटा क्षतिग्रस्त हो सकता है और यह किस परिणाम की ओर ले जाएगा यह एक लफ्फाजीपूर्ण सवाल है :)

चेतावनी २

V519 'पृष्ठभूमि' चर को क्रमिक रूप से दो बार मान दिया गया है। शायद यह एक गलती है। जाँच लाइनें: 1367, 1373। Map.cpp 1373

 void mapclass::loadlevel(....) { .... case 4: //The Warpzone tmap = warplevel.loadlevel(rx, ry, game, obj); fillcontent(tmap); roomname = warplevel.roomname; tileset = 1; background = 3; // <= dwgfx.rcol = warplevel.rcol; dwgfx.backgrounddrawn = false; warpx = warplevel.warpx; warpy = warplevel.warpy; background = 5; // <= if (warpy) background = 4; if (warpx) background = 3; if (warpx && warpy) background = 5; break; .... }

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

 void Game::loadquick(....) { .... else if (pKey == "frames") { frames = atoi(pText); frames = 0; } .... }

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

चेतावनी ३

V808 'pKey' ऑब्जेक्ट 'basic_string' प्रकार का बनाया गया था, लेकिन इसका उपयोग नहीं किया गया था। Editor.cpp 1866

 void editorclass::load(std::string &_path) { .... std::string pKey(pElem->Value()); .... if (pKey == "edEntities") { int i = 0; for (TiXmlElement *edEntityEl = pElem->FirstChildElement(); edEntityEl; edEntityEl = edEntityEl->NextSiblingElement()) { std::string pKey(edEntityEl->Value()); // <= //const char* pText = edEntityEl->GetText() ; if (edEntityEl->GetText() != NULL) { edentity[i].scriptname = std::string(edEntityEl->GetText()); } edEntityEl->QueryIntAttribute("x", &edentity[i].x); edEntityEl->QueryIntAttribute("y", &edentity[i].y); edEntityEl->QueryIntAttribute("t", &edentity[i].t); edEntityEl->QueryIntAttribute("p1", &edentity[i].p1); edEntityEl->QueryIntAttribute("p2", &edentity[i].p2); edEntityEl->QueryIntAttribute("p3", &edentity[i].p3); edEntityEl->QueryIntAttribute("p4", &edentity[i].p4); edEntityEl->QueryIntAttribute("p5", &edentity[i].p5); edEntityEl->QueryIntAttribute("p6", &edentity[i].p6); i++; } EditorData::GetInstance().numedentities = i; } .... }

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

इस प्रकार, यदि आप लूप के लिए pKey स्ट्रिंग के मान को एक्सेस करते हैं, तो आपको pElem-> Value () के बराबर मान मिलेगा, लेकिन यदि आप लूप के अंदर भी ऐसा ही करते हैं, तो आपको edEntityEl> मान () के बराबर मान मिलेगा। ओवरलैपिंग नाम एक नहीं बल्कि गंभीर गलती है, जिसे कोड समीक्षा के दौरान अपने दम पर खोजना बहुत मुश्किल हो सकता है।

चेतावनी ४

V805 प्रदर्शन में कमी। 'Strlen (str)> 0' कंस्ट्रक्शन का उपयोग करके एक खाली स्ट्रिंग की पहचान करना अक्षम है। एक और अधिक कुशल तरीका यह है कि जाँच करें: str [0]! = '\ 0'। फिजियोफेस्क 1604

 static char *prefDir = NULL; .... const char *PHYSFS_getPrefDir(const char *org, const char *app) { .... assert(strlen(prefDir) > 0); ... return prefDir; } /* PHYSFS_getPrefDir */

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

लेकिन हमें केवल यह जांचने की आवश्यकता है कि स्ट्रिंग गैर-रिक्त है! ऐसा करने के लिए, यह पता करें कि क्या स्ट्रिंग का पहला वर्ण टर्मिनल शून्य है। इसलिए, मुखर के अंदर इस जाँच को अनुकूलित करने के लिए, आपको लिखना चाहिए:

 str[0] != '\0'

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

चेतावनी ५

निम्नलिखित त्रुटि दिखाने के लिए, मुझे यहां दो टुकड़ों को संलग्न करने की आवश्यकता है: एंट्रेस क्लास और इसके कंस्ट्रक्टर की घोषणा। आइए घोषणा के साथ शुरू करें:

 class entclass { public: entclass(); void clear(); bool outside(); public: //Fundamentals bool active, invis; int type, size, tile, rule; int state, statedelay; int behave, animate; float para; int life, colour; //Position and velocity int oldxp, oldyp; float ax, ay, vx, vy; int cx, cy, w, h; float newxp, newyp; bool isplatform; int x1, y1, x2, y2; //Collision Rules int onentity; bool harmful; int onwall, onxwall, onywall; //Platforming specific bool jumping; bool gravity; int onground, onroof; int jumpframe; //Animation int framedelay, drawframe, walkingframe, dir, actionframe; int yp; int xp; };

इस वर्ग का निर्माता इस तरह दिखता है:

 entclass::entclass() { clear(); } void entclass::clear() { // Set all values to a default, // required for creating a new entity active = false; invis = false; type = 0; size = 0; tile = 0; rule = 0; state = 0; statedelay = 0; life = 0; colour = 0; para = 0; behave = 0; animate = 0; xp = 0; yp = 0; ax = 0; ay = 0; vx = 0; vy = 0; w = 16; h = 16; cx = 0; cy = 0; newxp = 0; newyp = 0; x1 = 0; y1 = 0; x2 = 320; y2 = 240; jumping = false; gravity = false; onground = 0; onroof = 0; jumpframe = 0; onentity = 0; harmful = false; onwall = 0; onxwall = 0; onywall = 0; isplatform = false; framedelay = 0; drawframe = 0; walkingframe = 0; dir = 0; actionframe = 0; }

पर्याप्त क्षेत्र, है ना? यह आश्चर्य की बात नहीं है कि यहां एक त्रुटि हुई, जिसके लिए पीवीएस-स्टूडियो ने चेतावनी जारी की:

V730 यह संभव है कि एक वर्ग के सभी सदस्यों को कंस्ट्रक्टर के अंदर शुरू नहीं किया गया हो। निरीक्षण करने पर विचार करें: oldxp, oldyp। Ent.cpp 3

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

चित्र 2

चेतावनी ६

कोड पर विचार करें:

 void mapclass::loadlevel(....) { .... std::vector<std::string> tmap; .... tmap = otherlevel.loadlevel(rx, ry, game, obj); fillcontent(tmap); .... //  tmap    . }

चेतावनी पीवीएस-स्टूडियो: वी 688 'टैम्प' स्थानीय चर में एक ही नाम है जो कक्षा के सदस्यों में से एक है, जिसके परिणामस्वरूप भ्रम हो सकता है। Map.cpp 1192

वास्तव में, यदि आप मैपक्लास वर्ग के अंदर देखते हैं, तो आप एक ही नाम के साथ एक ही वेक्टर पा सकते हैं:

 class mapclass { public: .... std::vector <int> roomdeaths; std::vector <int> roomdeathsfinal; std::vector <int> areamap; std::vector <int> contents; std::vector <int> explored; std::vector <int> vmult; std::vector <std::string> tmap; // <= .... };

दुर्भाग्य से, किसी फ़ंक्शन के अंदर एक ही नाम के साथ एक वेक्टर घोषित करना वेक्टर को वर्ग में घोषित अदृश्य बना देता है। यह पता चलता है कि पूरे लोडवेल फ़ंक्शन के दौरान टैम्प वेक्टर केवल फ़ंक्शन के अंदर बदलता है। कक्षा में घोषित वेक्टर अपरिवर्तित रहता है!

दिलचस्प है, पीवीएस-स्टूडियो ने 20 ऐसे कोड टुकड़े के रूप में खोज की! अधिकांश भाग के लिए, वे अस्थायी चर से जुड़े हैं, जो सुविधा के लिए, वर्ग के सदस्यों के रूप में घोषित किए गए थे। खेल के लेखक (और इसके एकमात्र डेवलपर) ने खुद लिखा था कि उन्हें यह बुरी आदत थी। आप इस बारे में इस पोस्ट में पढ़ सकते हैं जिसे मैंने इस लेख की शुरुआत में जोड़ा था।

वह यह भी नोट करता है कि इस तरह के नामकरण से कीड़े को पकड़ना हानिकारक और कठिन हो गया। खैर, ऐसे कीड़े वास्तव में हानिकारक हो सकते हैं, लेकिन उन्हें पकड़ने के लिए स्थैतिक विश्लेषण का उपयोग करना मुश्किल नहीं होगा :)

चेतावनी 7

V601 पूर्णांक प्रकार स्पष्ट रूप से चार प्रकार के लिए डाला जाता है। Game.cpp 4997

 void Game::loadquick(....) { .... else if (pKey == "totalflips") { totalflips = atoi(pText); } else if (pKey == "hardestroom") { hardestroom = atoi(pText); // <= } else if (pKey == "hardestroomdeaths") { hardestroomdeaths = atoi(pText); } .... }

यह समझने के लिए कि मामला क्या है, आइए कोड के दिए गए अनुभाग से चर की परिभाषाओं पर एक नज़र डालें:

 //Some stats: int totalflips; std::string hardestroom; int hardestroomdeaths;

चर कुलफल और कठफोड़वा पूर्णांक प्रकार के होते हैं, और इसलिए उनमें अटोई कार्य करने का परिणाम पूरी तरह से सामान्य है। लेकिन क्या होगा यदि आप std :: string को पूर्णांक मान असाइन करते हैं? यह पता चला है कि भाषा के दृष्टिकोण से, ऐसा असाइनमेंट पूरी तरह से मान्य है। नतीजतन, कुछ अतुलनीय मूल्य को सबसे कठिन चर में लिखा जाएगा!

चेतावनी 8

V1004 nullptr के खिलाफ सत्यापित होने के बाद 'pElem' पॉइंटर का उपयोग अनिश्चित रूप से किया गया था। चेक लाइनें: 1739, 1744। Editor.cpp 1744

 void editorclass::load(std::string &_path) { .... TiXmlHandle hDoc(&doc); TiXmlElement *pElem; TiXmlHandle hRoot(0); version = 0; { pElem = hDoc.FirstChildElement().Element(); // should always have a valid root // but handle gracefully if it does if (!pElem) { printf("No valid root! Corrupt level file?\n"); } pElem->QueryIntAttribute("version", &version); // <= // save this for later hRoot = TiXmlHandle(pElem); } .... }

विश्लेषक चेताते हैं कि nullptr के लिए जाँच करने के तुरंत बाद pElem पॉइंटर असुरक्षित रूप से उपयोग किया जाता है। यह सुनिश्चित करने के लिए कि विश्लेषक सही है, तत्व () फ़ंक्शन की परिभाषा पर एक नज़र डालें, जिसका रिटर्न मान pElem पॉइंटर को इनिशियलाइज़ करता है:

 /** @deprecated use ToElement. Return the handle as a TiXmlElement. This may return null. */ TiXmlElement *Element() const { return ToElement(); }

जैसा कि आप टिप्पणी से देख सकते हैं, यह फ़ंक्शन शून्य वापस आ सकता है।

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

चेतावनी ९

कोड के अगले भाग में, PVS-Studio ने चार चेतावनी जारी की:

V560 सशर्त अभिव्यक्ति का एक हिस्सा हमेशा सच होता है: x> = 0. editor.cpp 1137
V560 सशर्त अभिव्यक्ति का एक हिस्सा हमेशा सच होता है: y> = 0. editor.cpp 1137
V560 सशर्त अभिव्यक्ति का एक हिस्सा हमेशा सच होता है: x <40। editor.cpp 1137
V560 सशर्त अभिव्यक्ति का एक हिस्सा हमेशा सच होता है: y <30। editor.cpp 1137

 int editorclass::at( int x, int y ) { if(x<0) return at(0,y); if(y<0) return at(x,0); if(x>=40) return at(39,y); if(y>=30) return at(x,29); if(x>=0 && y>=0 && x<40 && y<30) { return contents[x+(levx*40)+vmult[y+(levy*30)]]; } return 0; }

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

इस जाँच को हटाया जा सकता है, क्योंकि निष्पादन धागा कभी भी " रिटर्न 0; " अभिव्यक्ति तक नहीं पहुंचेगा। हालांकि यह कार्यक्रम के तर्क को नहीं बदलता है, यह इसे अनावश्यक जांच और मृत कोड से मुक्त करेगा।

चेतावनी १०

खेल की सालगिरह पर अपने लेख में, टेरी विडंबना के साथ कहते हैं कि खेल के तर्क को नियंत्रित करने वाले तत्वों में से एक खेल :: अपडैटस्टेट () फ़ंक्शन से बहुत बड़ा स्विच था, जो विभिन्न गेम राज्यों की एक बड़ी संख्या के लिए तुरंत जिम्मेदार है। और यह बहुत उम्मीद थी कि मुझे निम्नलिखित चेतावनी मिलेगी:

V2008 साइक्लोमैटिक जटिलता: 548. 'गेम :: updatestate' फ़ंक्शन को फिर से शुरू करने पर विचार करें। Game.cpp 612

हां, आप सही ढंग से समझ गए हैं: पीवीएस-स्टूडियो ने 548 इकाइयों में एक फ़ंक्शन के चक्रीय जटिलता का अनुमान लगाया था। पांच सौ अड़तालीस !!! यह मैं समझता हूं - "स्वच्छ कोड।" और यह इस तथ्य के बावजूद कि, वास्तव में, एक फ़ंक्शन में स्विच अभिव्यक्ति से अधिक कुछ नहीं है। स्विच में ही, मैंने 300 से अधिक केस एक्सप्रेशन गिना।

हमारे कार्यालय में सबसे लंबे लेख के लिए लेखकों के बीच एक छोटी प्रतियोगिता है। मैं ख़ुशी से सभी फंक्शन कोड यहाँ (3450 पंक्तियों) लाऊँगा, लेकिन इस तरह की जीत बेईमानी होगी, इसलिए मैं अपने आप को केवल विशाल स्विच का हवाला देकर सीमित कर दूंगा। मैं इसे पालन करने और पूरे पैमाने का मूल्यांकन करने की सलाह देता हूं! वैसे, Game :: updatestate () के अलावा , PVS-Studio ने अत्यधिक साइक्लोमैटिक जटिलता के साथ 44 कार्यों के रूप में पाया, जिनमें से 10 में 200 से अधिक की जटिलता है।

चित्र 3

निष्कर्ष

मुझे लगता है कि लेख के लिए लिखित त्रुटियां पर्याप्त हैं। हां, परियोजना में बहुत सारी गलतियां थीं, लेकिन यह बिल्कुल चाल है: अपने कोड को निर्धारित करते हुए, टेरी कैवानघ ने दिखाया कि एक अच्छा खेल बनाने के लिए एक अच्छा प्रोग्रामर होना आवश्यक नहीं है। अब, 10 साल बाद, टेरी उन समय को विडंबना के साथ याद करते हैं। अपनी गलतियों से सीखना महत्वपूर्ण है, और अभ्यास ऐसा करने का सबसे अच्छा तरीका है। और अगर आपका अभ्यास अभी भी VVVVVVV जैसे गेम को जन्म दे सकता है, तो यह आम तौर पर बहुत खूबसूरत है! एह ... मैं जाऊंगा और मैं शायद इसे फिर से खेलूंगा :)

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

यदि आप इस लेख को अंग्रेजी बोलने वाले दर्शकों के साथ साझा करना चाहते हैं, तो कृपया अनुवाद के लिंक का उपयोग करें: जॉर्ज ग्रिबकोव। VVVVVV ??? VVVVVV !!! :) ।

VVVVVV ??? VVVVVV !!! :)