😓 🈳 💤 सुपर मारियो ब्रदर्स क्लोन गेम लिखना (भाग 2) ☯️ 🤴🏿 🧙

कैसे सुपर मारियो ब्रदर्स की तरह अपने खुद के platformer लिखने के लिए ट्यूटोरियल की एक श्रृंखला के दूसरे भाग में आपका स्वागत है!
पहले भाग में, हमने टाइल मैप के आधार पर एक सरल भौतिकी इंजन लिखा था।
दूसरे (और अंतिम) भाग में, हम कोलियो को हिलना और कूदना सिखाएंगे - किसी भी प्लेटफ़ॉर्मर का सबसे मज़ेदार हिस्सा!

हम एक स्तर पर खतरों से टकराव को ट्रैक करना सीखेंगे, जीत और हार को संभालेंगे; महान ध्वनि प्रभाव और संगीत जोड़ें!

दूसरा भाग पहले की तुलना में बहुत आसान (और छोटा) है - पिछली बार कड़ी मेहनत के बाद एक छोटा आराम! तो अपने कोदो कुंग फू को चालू करें और आनंद लें!

कोलियो ले जाएँ

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

Player.h में :

@property (nonatomic, assign) BOOL forwardMarch; @property (nonatomic, assign) BOOL mightAsWellJump;

और Player.m में सब कुछ संश्लेषित करें:

 @synthesize forwardMarch = _forwardMarch, mightAsWellJump = _mightAsWellJump;

अब GameLevelLayer में निम्नलिखित टच हैंडलिंग विधियों को जोड़ें :

मुझे क्लिक करें

 - (void)ccTouchesBegan:(NSSet *)touches withEvent:(UIEvent *)event { for (UITouch *t in touches) { CGPoint touchLocation = [self convertTouchToNodeSpace:t]; if (touchLocation.x > 240) { player.mightAsWellJump = YES; } else { player.forwardMarch = YES; } } } - (void)ccTouchesMoved:(NSSet *)touches withEvent:(UIEvent *)event { for (UITouch *t in touches) { CGPoint touchLocation = [self convertTouchToNodeSpace:t]; //   CGPoint previousTouchLocation = [t previousLocationInView:[t view]]; CGSize screenSize = [[CCDirector sharedDirector] winSize]; previousTouchLocation = ccp(previousTouchLocation.x, screenSize.height - previousTouchLocation.y); if (touchLocation.x > 240 && previousTouchLocation.x <= 240) { player.forwardMarch = NO; player.mightAsWellJump = YES; } else if (previousTouchLocation.x > 240 && touchLocation.x <=240) { player.forwardMarch = YES; player.mightAsWellJump = NO; } } } - (void)ccTouchesEnded:(NSSet *)touches withEvent:(UIEvent *)event { for (UITouch *t in touches) { CGPoint touchLocation = [self convertTouchToNodeSpace:t]; if (touchLocation.x < 240) { player.forwardMarch = NO; } else { player.mightAsWellJump = NO; } } }

ऊपर दिए गए कोड को समझना बहुत आसान है। यदि स्क्रीन टच का एक्स-समन्वय 240 (आधी स्क्रीन) से कम है, तो हम आगे के चर को YES पर सेट करते हैं। अन्यथा (यदि X निर्देशांक 240 से अधिक है) तो हम चर मेयरों को मान प्रदान करते हैं।
छूना थोड़ा अधिक जटिल तरीका है। हमें चर के मूल्य को केवल तभी बदलना होगा जब स्पर्श स्क्रीन के मध्य को पार कर जाए। इसलिए हमें पिछले टच को भी ध्यान में रखना चाहिए - पिछला टच चर। दूसरे शब्दों में, हम बस जाँच करते हैं कि किस तरफ से चौराहा हुआ और क्रमशः बूलियन चर के मूल्यों को बदलते हैं।
हम चाहते हैं कि जब कोई खिलाड़ी स्क्रीन के एक निश्चित क्षेत्र को छूना बंद कर दे, तो केवल आवश्यक बूलियन चर बंद हो जाते हैं।
हालांकि, यह स्पर्श के उचित संचालन के लिए कुछ और चीजों को बदलने के लायक है। Init विधि में निम्न पंक्ति जोड़ें:

  self.isTouchEnabled = YES;

हमें AppDelegate.m में मल्टीटच सक्षम करने की आवश्यकता है (अचानक हमारा खिलाड़ी उसी समय कूदना और आगे बढ़ना चाहता है)। लाइन से पहले निम्नलिखित जोड़ें [संचालक_ पुशसेकेन: [गेमलेवलर दृश्य]]; :

  [glView setMultipleTouchEnabled:YES];

अब जब हमारे पास प्लेयर क्लास के ऑब्जेक्ट में वैरिएबल का मूल्य है, तो हम अपडेट पद्धति में कुछ कोड जोड़ सकते हैं ताकि कोलियो हिल सकें। चलिए आगे बढ़ते हैं। Player.m में अद्यतन विधि को निम्न में बदलें:

मुझे क्लिक करें

 -(void)update:(ccTime)dt { CGPoint gravity = ccp(0.0, -450.0); CGPoint gravityStep = ccpMult(gravity, dt); CGPoint forwardMove = ccp(800.0, 0.0); CGPoint forwardStep = ccpMult(forwardMove, dt); //1 self.velocity = ccpAdd(self.velocity, gravityStep); self.velocity = ccp(self.velocity.x * 0.90, self.velocity.y); //2 if (self.forwardMarch) { self.velocity = ccpAdd(self.velocity, forwardStep); } //3 CGPoint minMovement = ccp(0.0, -450.0); CGPoint maxMovement = ccp(120.0, 250.0); self.velocity = ccpClamp(self.velocity, minMovement, maxMovement); //4 CGPoint stepVelocity = ccpMult(self.velocity, dt); self.desiredPosition = ccpAdd(self.position, stepVelocity); }

चलिए इस कोड को चरण दर चरण लेते हैं:

हम फ़ॉरवर्डमोव पावर को जोड़ते हैं, जो तब लागू होता है जब खिलाड़ी स्क्रीन को छूता है। मुझे याद दिलाएं कि हम निरंतर गति प्राप्त करने के लिए इस दर (800 अंक प्रति सेकंड) को फ्रेम दर के आधार पर बदलते हैं।
यहां हम घर्षण जोड़ते हैं। हम भौतिकी का उपयोग वैसे ही करते हैं जैसे हमने गुरुत्वाकर्षण के साथ किया था। हर फ्रेम में फोर्सेस लगाई जाएंगी। जब सत्ता चलती है, हम चाहते हैं कि खिलाड़ी रुक जाए। हम 0.90 के बल के साथ घर्षण लागू करते हैं। दूसरे शब्दों में, हम प्रत्येक फ्रेम में 10% की गति को कम करते हैं।
तीसरे खंड में, हम जांचते हैं कि खिलाड़ी स्क्रीन को छू रहा है या नहीं, यदि आवश्यक हो, तो फ़ॉरवर्डस्टेप का बल।
खंड चार में, हमने सीमाएँ निर्धारित की हैं। अधिकतम खिलाड़ी की गति को सीमित करें। दोनों क्षैतिज (दौड़ने की गति) और ऊर्ध्वाधर (कूद गति, गुरुत्वाकर्षण गति)।
घर्षण बल और सीमाएं हमें खेल में प्रक्रियाओं की गति को नियंत्रित करने की अनुमति देती हैं। इन सीमाओं का होना समस्या को पहले ट्यूटोरियल से बहुत तेज़ गति से रोकता है।
हम चाहते हैं कि खिलाड़ी एक या अधिक सेकंड में अधिकतम गति तक पहुंच जाए। इस प्रकार, कोअला के आंदोलन अभी भी स्वाभाविक दिखेंगे और, एक ही समय में, नियंत्रण में दे देंगे। हमने अधिकतम गति के लिए 120 (स्क्रीन प्रति सेकंड की चौड़ाई का एक चौथाई) की सीमा निर्धारित की है।
यदि हम अपने खिलाड़ी के त्वरण पट्टी को बढ़ाना चाहते हैं, तो हमें क्रमशः दोनों मूल्यों को बढ़ाना होगा: फॉरवर्डम और घर्षण बल (0.90)। अगर हम खिलाड़ी की अधिकतम गति को बढ़ाना चाहते हैं, तो हमें सिर्फ 120 के मूल्य में वृद्धि करने की आवश्यकता है। हम कूदने की गति को भी 250 और गिरावट की गति को 450 तक सीमित करते हैं।

प्रोजेक्ट चलाएं। यदि आप स्क्रीन के बाईं ओर क्लिक करते हैं, तो कोलियो हिलना शुरू कर देना चाहिए। हमारी कोआला चाल तेज देखो!

आगे हम कोआला कूदेंगे!

हमारे खसखस उसे कर देगा ... कूद, कूद!

जंपिंग किसी भी प्लेटफ़ॉर्म गेम का एक अभिन्न हिस्सा है जिसमें बहुत मज़ा आता है। हमें यह सुनिश्चित करने की आवश्यकता है कि कूद चिकनी और अच्छी तरह से कैलिब्रेटेड है। इस ट्यूटोरियल में, हम यहां वर्णित सोनिक हेज हॉग जॉग एल्गोरिथ्म का उपयोग करते हैं ।
यदि (self.forwardMarch) { से पहले अद्यतन विधि में निम्नलिखित को जोड़ें:

 CGPoint jumpForce = ccp(0.0, 310.0); if (self.mightAsWellJump && self.onGround) { self.velocity = ccpAdd(self.velocity, jumpForce); }

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

  CGPoint jumpForce = ccp(0.0, 310.0); float jumpCutoff = 150.0; if (self.mightAsWellJump && self.onGround) { self.velocity = ccpAdd(self.velocity, jumpForce); } else if (!self.mightAsWellJump && self.velocity.y > jumpCutoff) { self.velocity = ccp(self.velocity.x, jumpCutoff); }

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

हमने कोलियो को दौड़ने और कूदने के लिए बनाया, लेकिन वह स्क्रीन के किनारे से तेजी से भागता है। इसे ठीक करने का समय आ गया है!
सेल मानचित्र ट्यूटोरियल से GameLevelLayer.m के लिए निम्नलिखित स्निपेट जोड़ें:

मुझे क्लिक करें

 - (void)setViewpointCenter:(CGPoint) position { CGSize winSize = [[CCDirector sharedDirector] winSize]; int x = MAX(position.x, winSize.width / 2); int y = MAX(position.y, winSize.height / 2); x = MIN(x, (map.mapSize.width * map.tileSize.width) - winSize.width / 2); y = MIN(y, (map.mapSize.height * map.tileSize.height) - winSize.height/2); CGPoint actualPosition = ccp(x, y); CGPoint centerOfView = ccp(winSize.width/2, winSize.height/2); CGPoint viewPoint = ccpSub(centerOfView, actualPosition); map.position = viewPoint; }

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

  [self setViewpointCenter:player.position];

प्रोजेक्ट चलाएं। कोआलिओ पूरे स्तर से चल सकता है!

हार की पीड़ा

दो परिणाम हैं: या तो जीत या हार।
सबसे पहले, हम हार के परिदृश्य से निपटेंगे। हमारे स्तर पर खतरे हैं। यदि खिलाड़ी खतरे में है, तो खेल समाप्त हो जाता है।
चूंकि खतरे तय कोशिकाएं हैं, इसलिए हम उनके साथ पिछले ट्यूटोरियल से बाधाओं के रूप में काम करेंगे। हालांकि, टकराव का पता लगाने के बजाय, हम बस खेल को समाप्त कर देंगे। हम सफलता की राह पर हैं - बस थोड़ा सा बचा है!
GameLevelLayer.m के लिए निम्न विधि जोड़ें:

 - (void)handleHazardCollisions:(Player *)p { NSArray *tiles = [self getSurroundingTilesAtPosition:p.position forLayer:hazards ]; for (NSDictionary *dic in tiles) { CGRect tileRect = CGRectMake([[dic objectForKey:@"x"] floatValue], [[dic objectForKey:@"y"] floatValue], map.tileSize.width, map.tileSize.height); CGRect pRect = [p collisionBoundingBox]; if ([[dic objectForKey:@"gid"] intValue] && CGRectIntersectsRect(pRect, tileRect)) { [self gameOver:0]; } } }

उपरोक्त सभी कोड आपको परिचित होने चाहिए, क्योंकि यह सिर्फ checkAndResolveCollisions विधि से कॉपी किया गया है। एकमात्र नवाचार गेमओवर विधि है। यदि खिलाड़ी हार जाता है तो हम उसे 0 भेजते हैं, और यदि वह जीता है तो 1।
हम दीवारों की परत के बजाय खतरों की परत का उपयोग करते हैं, इसलिए हमें चर CCTMXLayer * खतरों की घोषणा करने की आवश्यकता है ; निष्पादन योग्य की शुरुआत में @ interface । इसे इनिट विधि में जोड़ें (दीवारों की परत के लिए चर घोषित करने के तुरंत बाद):

  hazards = [map layerNamed:@"hazards"];

केवल एक ही चीज़ बची है जो अद्यतन विधि में निम्नलिखित कोड जोड़ रही है:

 - (void)update:(ccTime)dt { [player update:dt]; [self handleHazardCollisions:player]; [self checkForAndResolveCollisions:player]; [self setViewpointCenter:player.position]; }

अब, यदि कोई खिलाड़ी खतरों की परत से किसी भी खतरनाक सेल में उड़ जाता है, तो हम गेमऑवर कहेंगे। यह विधि आपके द्वारा खोए गए संदेश के साथ "पुनः आरंभ करें" बटन को प्रदर्शित करेगी (या जीत गई - यह भी होता है):

मुझे क्लिक करें

 - (void)gameOver:(BOOL)won { gameOver = YES; NSString *gameText; if (won) { gameText = @"You Won!"; } else { gameText = @"You have Died!"; } CCLabelTTF *diedLabel = [[CCLabelTTF alloc] initWithString:gameText fontName:@"Marker Felt" fontSize:40]; diedLabel.position = ccp(240, 200); CCMoveBy *slideIn = [[CCMoveBy alloc] initWithDuration:1.0 position:ccp(0, 250)]; CCMenuItemImage *replay = [[CCMenuItemImage alloc] initWithNormalImage:@"replay.png" selectedImage:@"replay.png" disabledImage:@"replay.png" block:^(id sender) { [[CCDirector sharedDirector] replaceScene:[GameLevelLayer scene]]; }]; NSArray *menuItems = [NSArray arrayWithObject:replay]; CCMenu *menu = [[CCMenu alloc] initWithArray:menuItems]; menu.position = ccp(240, -100); [self addChild:menu]; [self addChild:diedLabel]; [menu runAction:slideIn]; }

पहली पंक्ति गेमऑवर चर घोषित करती है। कोलियो की स्थिति में कोई भी बदलाव करने के लिए अपडेट विधि को रोकने के लिए हम इस चर का उपयोग करेंगे। शाब्दिक रूप से एक मिनट में हम इसे कर लेंगे।
अगला, कोड पाठ (लेबल) बनाता है और इसे जीता या हारा हुआ मान देता है। हम एक "रिस्टार्ट" बटन भी बनाते हैं।
ये ब्लॉक-आधारित CCMenu ऑब्जेक्ट मेथड उपयोग करने के लिए बहुत आसान हैं। हमारे मामले में, हम बस स्तर को शुरू करने के लिए अपने स्तर को इसकी एक प्रति के साथ प्रतिस्थापित करते हैं। हम CCAction और CCMove का उपयोग केवल खूबसूरती से बटन को चेतन करने के लिए करते हैं।
एक और चीज करने के लिए बूलियन वैरिएबल गेमऑवर को GameLevelLayer क्लास में जोड़ना है। यह एक स्थानीय चर होगा, क्योंकि हम इसे कक्षा के बाहर उपयोग नहीं करेंगे। GameLevelLayer.m फ़ाइल की शुरुआत में निम्नलिखित को @ interface में जोड़ें:

 CCTMXLayer *hazards; BOOL gameOver;

अद्यतन विधि को निम्नानुसार बदलें:

 - (void)update:(ccTime)dt { if (gameOver) { return; } [player update:dt]; [self checkForAndResolveCollisions:player]; [self handleHazardCollisions:player]; [self setViewpointCenter:player.position]; }

गेम लॉन्च करें, स्टडेड फ्लोर ढूंढें और उस पर कूदें! आपको कुछ इस तरह से देखना चाहिए:

बस इसे अक्सर दोहराएं नहीं, अन्यथा पशु अधिवक्ताओं के साथ समस्याएं दिखाई दे सकती हैं! :]

मौत के घाट उतार दिया

अब कोशिकाओं के बीच एक छेद में गिरने का एक परिदृश्य जोड़ें। इस मामले में, हम खेल को समाप्त करते हैं।
अभी, जब यह क्रैश हो जाता है, तो कोड "TMXLayer: अमान्य स्थिति" के साथ क्रैश हो जाता है। (डर!) यह वह जगह है जहाँ हमें हस्तक्षेप करने की आवश्यकता है।
निम्नलिखित कोड को GameLevelLayer.m में, getSurroundingTilesAtPosition में जोड़ें: पद्धति, टाइलगाइड लाइन से पहले :

 if (tilePos.y > (map.mapSize.height - 1)) { //fallen in a hole [self gameOver:0]; return nil; }

यह कोड गेमऑवर कार्रवाई को ट्रिगर करेगा और कोशिकाओं की एक सरणी बनाने की प्रक्रिया को रोक देगा। हमें भी चेक में सभी कोशिकाओं से गुजरने से लूप को रोकने की जरूरत है। NSArray * टाइल्स = [आत्म getSurroundingTilesAtPosition: p.position forLayer: wall] के बाद कोड का एक ब्लॉक जोड़ें ; :

  if (gameOver) { return; }

यह लूप की चुनौती और खेल के अनावश्यक क्रैश को रोक देगा।
अब गेम लॉन्च करें। रसातल खोजें जिसमें आप कूद सकते हैं, और ... कोई छंटनी नहीं! खेल इच्छानुसार काम करता है।

जीत!

अब, इस मामले के साथ काम करें जब हमारा कोलियो खेल जीतता है!

हम सभी अपने कोअला की एक्स-स्थिति का पालन करते हैं और एक जीत संदेश के साथ एक स्क्रीन दिखाते हैं यदि यह एक निश्चित निशान को पार करता है। इस स्तर की लंबाई 3400 पिक्सेल है। हम जीतने वाले चिह्न को 3130 पिक्सेल की दूरी पर लगाएंगे।
GameLevelLayer.m में एक नई विधि जोड़ें और अपडेट विधि को अपडेट करें:

 - (void)checkForWin { if (player.position.x > 3130.0) { [self gameOver:1]; } }

 - (void)update:(ccTime)dt { [player update:dt]; [self handleHazardCollisions:player]; [self checkForWin]; [self checkForAndResolveCollisions:player]; [self setViewpointCenter:player.position]; }

दौड़ो, जीतने की कोशिश करो। यदि यह काम करता है, तो आपको निम्नलिखित देखना चाहिए:

महान संगीत और ध्वनि प्रभाव

यह महान संगीत और ध्वनि प्रभाव के लिए समय है!
चलिए शुरू करते हैं। GameLevelLayer.m और Player.m की शुरुआत में निम्नलिखित जोड़ें:

 #import "SimpleAudioEngine.h"

अब GameLevelLayer फ़ाइल के init विधि में निम्न पंक्ति जोड़ें।

  [[SimpleAudioEngine sharedEngine] playBackgroundMusic:@"level1.mp3"];

हमने अभी कुछ अच्छे गेम म्यूज़िक शुरू किए हैं। संगीत लिखने के लिए Incompetech.com के केविन का धन्यवाद ( भंगुर रील )। उसके पास सीसी लाइसेंस वाले संगीत का एक पूरा बादल है!
अब कूदने की आवाज़ जोड़ें। Player.m पर जाएं और अपडेट विधि के जंप कोड में निम्नलिखित जोड़ें:

 if (self.mightAsWellJump && self.onGround) { self.velocity = ccpAdd(self.velocity, jumpForce); [[SimpleAudioEngine sharedEngine] playEffect:@"jump.wav"]; } else if (!self.mightAsWellJump && self.velocity.y > jumpCutoff) { self.velocity = ccp(self.velocity.x, jumpCutoff); }

और अंत में, हार की आवाज खेलते हैं जब कोलियो एक खतरनाक सेल को छूता है या एक छेद में गिरता है। GameLevelLayer.m फ़ाइल की गेमऑवर पद्धति के लिए निम्नलिखित जोड़ें:

 - (void)gameOver { gameOver = YES; [[SimpleAudioEngine sharedEngine] playEffect:@"hurt.wav"]; CCLabelTTF *diedLabel = [[CCLabelTTF alloc] initWithString:@"You have Died!" fontName:@"Marker Felt" fontSize:40]; diedLabel.position = ccp(240, 200);

लॉन्च करें और नई अच्छी धुनों का आनंद लें।
वह सब है! आपने एक प्लेटफ़ॉर्मर लिखा! आप महान हैं!

और यहाँ हमारी पूर्ण परियोजना का स्रोत कोड है ।

अनुवादक का नोट

मैंने समय-समय पर raywenderlich.com से ट्यूटोरियल ट्रांसलेट करने का फैसला किया।
मेरा अगला लक्ष्य Box2D और Cocos2D पर आधारित Fruit Ninja जैसा अपना गेम कैसे बनाना है, इस पर ट्यूटोरियल की एक श्रृंखला का अनुवाद करना है।
टिप्पणियों में लिखें यदि यह इसके लायक है। यदि स्थानांतरण मांग में है, तो मैं अनुवाद करूंगा।
पाए गए सभी अशुद्धियों और टाइपो के बारे में, कृपया इब्राहीम या यहाँ टिप्पणियों में लिखें।
मुझे ट्यूटोरियल के बारे में सभी सवालों के जवाब देने में खुशी होगी!

सुपर मारियो ब्रदर्स क्लोन गेम लिखना (भाग 2)

कोलियो ले जाएँ

हमारे खसखस ​​उसे कर देगा ... कूद, कूद!

हार की पीड़ा

मौत के घाट उतार दिया

जीत!

महान संगीत और ध्वनि प्रभाव

अनुवादक का नोट

More articles:

हमारे खसखस उसे कर देगा ... कूद, कूद!