जैसा कि मैंने iOS के तहत फुटबॉलोलॉइड लिखा है

सबसे सम्मानजनक हैबरालुडी को बधाई!


बहुत समय पहले नहीं, नई नौकरी की खोज करते समय, मुझे ZeptoLab से एक बहुत ही दिलचस्प परीक्षण कार्य मिला: एक पार्टी में कुछ दिनों के लिए Cocos2d / Box2d, इत्यादि जैसे कि "क्लीन" ओपनजीएल का उपयोग किए बिना iOS के लिए एक अरकानॉइड लिखें। जो मुझे बहुत दिलचस्प लगा। वैसे, होबे पर इस कार्य के बारे में पहले से ही लिखा था , और यहां तक ​​कि डिब्रीफिंग की व्यवस्था भी की। इसलिए, मैंने भाग्य को चुनौती दी और ग्राफिक मोड में वासिक के साथ स्कूल अभ्यास के बाद पहली बार gameev लिया!

मैं स्पष्ट करूंगा कि मुझे पहले से ही ओपनजीएल का कुछ ज्ञान था, लेकिन बहुत, बहुत सतही। हम कह सकते हैं कि वे लगभग बिल्कुल भी नहीं थे, मुझे सिर्फ यह पता था कि एक व्यूपोर्ट क्या है और वहां कुछ स्प्राइट्स हैं, कि ट्रांसफॉर्मेशन मैट्रिसेस हैं ... इसलिए यह आर्टिकल " ओपन ओपन पर iOS के लिए एक सरल गेम कैसे लिखें " शीर्षक हो सकता है उसे जाने बिना, "लेकिन यह बहुत लंबा है।

सामान्य तौर पर, यदि आप रुचि रखते हैं कि मैंने यह ~ 10 घंटे के विकास और ~ 2 घंटे पढ़ने के लिए कैसे किया, तो मैं बिल्ली के लिए पूछता हूं। (सावधानी! कोड का एक बहुत! छोटी तस्वीरें! अंत में गितूब और आराम वीडियो के लिए लिंक!)

हम ईमानदार होंगे। Image_to_attract_attention ™ मेरे लिए क्या हुआ का स्क्रीनशॉट नहीं है। और यहाँ मेरे साथ क्या हुआ:


मुझे इस धोखे के लिए क्षमा करें, लेकिन आप अभी भी मेरे लेख में रुचि रखते हैं, है ना? )

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

सबसे पहले, खेल के लिए एक खाली प्रोजेक्ट बनाएं। Xcode में, फ़ाइल -> नया -> प्रोजेक्ट ... पर क्लिक करें, iOS टेम्प्लेट -> एप्लिकेशन -> ओपनजीएल गेम चुनें । व्यक्तिगत रूप से, मैंने एआरसी के साथ और बिना स्टोरीबॉर्ड के एक परियोजना को चुना, लेकिन आप, प्रिय पाठक, आप जैसे चाहें वैसा करने के लिए स्वतंत्र हैं। ठीक है, परियोजना बनाई गई है, अब हम तुरंत रन दबा सकते हैं और कताई क्यूब्स का आनंद ले सकते हैं। लेकिन यह बिल्कुल वैसा नहीं है जैसा हम करना चाहते थे, इसलिए हम लगभग हर चीज को हटा देते हैं, जो हमारे लिए डाला जाता है, हम केवल आवश्यक छोड़ देते हैं। सबसे पहले, हम जोड़े गए शेड्स को हटाते हैं, ViewController.m से हम interface ViewController () जाने वाले सभी एनम और ग्लोबल वैरिएबल्स को हटाते हैं interface ViewController () अब हम अतिरिक्त तरीकों को loadShaders, compileShader:type:file:, linkProgram:, validateProgram: : loadShaders, compileShader:type:file:, linkProgram:, validateProgram: हमारे सबसे सरल उदाहरण में। हम shaders का उपयोग नहीं करेंगे। बेशक, आप उनका उपयोग कर सकते हैं यदि आप जानते हैं कि कैसे और क्यों, लेकिन मैंने इस के साथ परेशान नहीं किया =)।

अगला, हम सभी शेष विधियों से सभी अतिरिक्त बाहर फेंक देते हैं। setupGL और tearDownGL हम एक नज़र में लाएंगे:

 - (void)setupGL { [EAGLContextsetCurrentContext:self.context]; self.effect = [[GLKBaseEffectalloc] init]; } - (void)tearDownGL { [EAGLContextsetCurrentContext:self.context]; self.effect = nil; } 

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

 #define kGameStateNone 0 #define kGameStateLose 1 #define kGameStateWon 2 @property (assign) int gameState; // see kGameState... @property (assign) BOOL gameRunning; - (void)loadBricks; - (void)startGame; - (void)endGameWithWin:(BOOL)win; 

वे किसके लिए जिम्मेदार हैं - और कोई टिप्पणी स्पष्ट नहीं है। खैर, अब खेल के तर्क के बारे में सोचने का समय है, अधिक सटीक, कार्यक्रम के तर्क के बारे में। हम क्या और कैसे करेंगे? हमारे पास क्या वस्तुएं होंगी? इसके लिए आपको क्या करने की आवश्यकता है?

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

 @interface GameSprite : NSObject - (id)initWithTexture:(GLKTextureInfo *)textureInfo effect:(GLKBaseEffect *)effect; - (id)initWithImage:(UIImage *)image effect:(GLKBaseEffect *)effect; - (void)render; - (void)update:(float)dt; - (CGRect)boundingRect; @property (assign) GLKVector2 position; @property (assign) CGSize contentSize; @property (assign) GLKVector2 moveVelocity; // points/sec @end 

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

 typedef struct { CGPoint geometryVertex; CGPoint textureVertex; } TexturedVertex; typedef struct { TexturedVertex bl; TexturedVertex br; TexturedVertex tl; TexturedVertex tr; } TexturedQuad; 

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

 @interface GameSprite() @property (strong) GLKBaseEffect *effect; @property (assign) TexturedQuad quad; @property (strong) GLKTextureInfo *textureInfo; - (void)initQuadAndSize; @end 

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

 - (id)initWithTexture:(GLKTextureInfo *)textureInfo effect:(GLKBaseEffect *)effect { if ((self = [super init])) { self.effect = effect; self.textureInfo = textureInfo; if (self.textureInfo == nil) { NSLog(@"Error loading texture! Texture info is nil!"); return nil; } [self initQuadAndSize]; } return self; } - (id)initWithImage:(UIImage *)image effect:(GLKBaseEffect *)effect { if ((self = [super init])) { self.effect = effect; NSDictionary *options = [NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:YES], GLKTextureLoaderOriginBottomLeft, nil]; NSError *error; self.textureInfo = [GLKTextureLoader textureWithCGImage:image.CGImage options:options error:&error]; if (self.textureInfo == nil) { NSLog(@"Error loading image: %@", [error localizedDescription]); return nil; } [self initQuadAndSize]; } return self; } - (void)initQuadAndSize { self.contentSize = CGSizeMake(self.textureInfo.width, self.textureInfo.height); TexturedQuad newQuad; newQuad.bl.geometryVertex = CGPointMake(0, 0); newQuad.br.geometryVertex = CGPointMake(self.textureInfo.width, 0); newQuad.tl.geometryVertex = CGPointMake(0, self.textureInfo.height); newQuad.tr.geometryVertex = CGPointMake(self.textureInfo.width, self.textureInfo.height); newQuad.bl.textureVertex = CGPointMake(0, 0); newQuad.br.textureVertex = CGPointMake(1, 0); newQuad.tl.textureVertex = CGPointMake(0, 1); newQuad.tr.textureVertex = CGPointMake(1, 1); self.quad = newQuad; } 

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

अब सबसे दिलचस्प भाग पर चलते हैं - स्प्राइट का प्रतिपादन, जिसके लिए render विधि जिम्मेदार है!

 - (void)render { self.effect.texture2d0.name = self.textureInfo.name; self.effect.texture2d0.enabled = YES; self.effect.transform.modelviewMatrix = self.modelMatrix; [self.effect prepareToDraw]; long offset = (long)&_quad; glEnableVertexAttribArray(GLKVertexAttribPosition); glEnableVertexAttribArray(GLKVertexAttribTexCoord0); glVertexAttribPointer(GLKVertexAttribPosition, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedVertex), (void *) (offset + offsetof(TexturedVertex, geometryVertex))); glVertexAttribPointer(GLKVertexAttribTexCoord0, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedVertex), (void *) (offset + offsetof(TexturedVertex, textureVertex))); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); } 

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

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

 - (GLKMatrix4)modelMatrix { GLKMatrix4 modelMatrix = GLKMatrix4Identity; modelMatrix = GLKMatrix4Translate(modelMatrix, self.position.x, self.position.y, 0); modelMatrix = GLKMatrix4Translate(modelMatrix, -self.contentSize.width / 2, -self.contentSize.height / 2, 0); return modelMatrix; } 

यहां भी, सब कुछ सरल है: आइडेंटिटी मैट्रिक्स (पहचान एक, जो कुछ भी नहीं करता है) को ले लो, स्वयं निर्देशन में निर्देशांक की उत्पत्ति का अनुवाद करें, और फिर इसे स्प्राइट के बीच में ले जाएं। स्प्राइट्स के एक गुच्छा में हेरफेर करते समय यह बहुत सुविधाजनक है। अब, update: लिए एक स्टब बनाया गया है update: हम अपना पहला स्प्राइट बना सकते हैं और उसमें संसाधनों से एक तस्वीर लोड कर सकते हैं। और हमारे ViewController में, इसे आकर्षित करें:

 - (void)viewDidLoad { [super viewDidLoad]; self.context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2]; if (!self.context) { NSLog(@"Failed to create ES context"); } [self setupGL]; GLKView *view = (GLKView *)self.view; view.context = self.context; GLKMatrix4 projectionMatrix = GLKMatrix4MakeOrtho(0, 320, 0, 480, -1024, 1024); self.effect.transform.projectionMatrix = projectionMatrix; // initializing game state self.gameRunning = NO; self.gameState = kGameStateNone; // initializing sprites self.testSprite = [[GameSpritealloc] initWithImage:[UIImageimageNamed:@"myImage"] effect:self.effect]; self.testSprite .position = GLKVector2Make(160, 35); } - (void)glkView:(GLKView *)view drawInRect:(CGRect)rect { glClearColor(1.f, 1.f, 1.f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); [self.testSprite render]; } 

अच्छा, बुरा नहीं? एक तस्वीर अब हमारे खेल मैदान पर खींची जा रही है। हां, हम दोस्तों को बुला सकते हैं और दावा कर सकते हैं कि हमने लगभग खेल लिखा है! =)

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

 @property (strong, nonatomic) GameSprite *playerBat; @property (strong, nonatomic) GameSprite *ball; @property (strong, nonatomic) GameSprite *background; @property (strong, nonatomic) GameSprite *menuDimmer; @property (strong, nonatomic) GameSprite *menuCaption; @property (strong, nonatomic) GameSprite *menuCaptionWon; @property (strong, nonatomic) GameSprite *menuCaptionLose; @property (strong, nonatomic) GameSprite *menuStartButton; @property (strong, nonatomic) NSMutableArray *bricks; 

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

 101101 111111 010010 111111 000000 111111 

प्रारूप स्व-स्पष्ट प्रतीत होता है, है ना? 0 - कोई ईंट नहीं, 1 - वहाँ है। ठीक है, यदि आप दूसरे प्रकार की ईंट बनाना चाहते हैं, तो हम संख्या 2, 3, 4 और इतने पर प्रवेश करते हैं। लेकिन यह भविष्य के लिए आहत है। ईंट लोडिंग फ़ंक्शन भी बहुत स्पष्ट है:

 - (void)loadBricks { // assuming 6x6 brick matrix, each brick is 50x10 NSError *error; [NSBundle mainBundle] ; NSStringEncoding encoding; NSString *filePath = [[NSBundle mainBundle] pathForResource:@"level1" ofType:@"txt"]; NSString *levelData = [NSString stringWithContentsOfFile:filePath usedEncoding:&encoding error:&error]; if (levelData == nil) { NSLog(@"Error loading level data! %@", error); return; } levelData = [[levelData componentsSeparatedByCharactersInSet: [NSCharacterSet whitespaceAndNewlineCharacterSet]] componentsJoinedByString: @""]; if ([levelData length] < (6*6)) { NSLog(@"Level data has incorrect size!"); return; } NSMutableArray *loadedBricks = [NSMutableArray array]; UIImage *brickImage = [UIImage imageNamed:@"brick1"]; NSDictionary *options = [NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithBool:YES], GLKTextureLoaderOriginBottomLeft, nil]; GLKTextureInfo *textureInfo = [GLKTextureLoader textureWithCGImage:brickImage.CGImage options:options error:&error]; if (textureInfo == nil) { NSLog(@"Error loading image: %@", [error localizedDescription]); return; } for (int i = 0; i < 6; i++) { for (int j = 0; j < 6; j++) { if ([levelData characterAtIndex:j + i * 6] == '1') { GameSprite *brickSprite = [[GameSprite alloc] initWithTexture:textureInfo effect:self.effect]; brickSprite.position = GLKVector2Make((j + 1) * 50.f - 15.f, 480.f - (i + 1) * 10.f - 15.f); [loadedBricks addObject:brickSprite]; } } } self.bricks = loadedBricks; } 

खैर, अब हमने ईंटें भी लाद दीं। आप हमारे खेल को चला सकते हैं और ईंटों की पंक्तियों, हमारे बल्ले और गेंद की प्रशंसा कर सकते हैं, और यह सब हमारी पृष्ठभूमि की पृष्ठभूमि के खिलाफ है। अरे हाँ, हम यह नहीं देख पाए, हम glkView:drawInRect: प्रतिपादन जोड़ना भूल गए glkView:drawInRect: प्रतिपादन को क्रम में जोड़ें: पहले पृष्ठभूमि, फिर बिट्स, फिर सभी ईंटें, और अंत में - गेंद। और अब आप प्रशंसा कर सकते हैं! =)

लेकिन ऐसा कैसे? गेंद क्यों नहीं चलती? यह एक तस्वीर नहीं है, यह एक खेल है, जिसका मतलब है कि गेंद को कहीं उड़ना चाहिए! गेंद को उड़ने के लिए, उसे गति निर्धारित करने की आवश्यकता होती है, और स्प्राइट विधि में update: आपको इस गति को ध्यान में रखना होगा और निर्देशांक बदलना होगा:

 - (void)update:(float)dt { GLKVector2 curMove = GLKVector2MultiplyScalar(self.moveVelocity, dt); self.position = GLKVector2Add(self.position, curMove); } 

और हमारे ViewController के update विधि में, आपको गेंद के स्प्राइट को अपडेट करने की आवश्यकता है:

  [self.ball update:self.timeSinceLastUpdate]; 

अब आप startGame में गेंद को गैर-शून्य गति पर सेट कर सकते हैं - और गेंद उड़ जाएगी!

 - (void)startGame { self.gameRunning = YES; self.gameState = kGameStateNone; [selfloadBricks]; self.ball.position = GLKVector2Make(160, 80); self.ball.moveVelocity = GLKVector2Make(120, 240); } 

ठीक है, अब चलो इस विधि को viewDidLoad में कॉल करते हैं - और गेंद उड़ जाएगी, लेकिन - जल्दी से स्क्रीन से उड़ान viewDidLoad । हम्म, उदास! खैर, हम दीवारों के साथ गेंद के टकराव और टकराव को संभालने पर विचार करना शुरू करते हैं। तैयार update विधि में, दीवारों के साथ गेंद की टक्कर जोड़ें:

 // checking for walls // left if (self.ball.boundingRect.origin.x <= 0) { self.ball.moveVelocity = GLKVector2Make(-self.ball.moveVelocity.x, self.ball.moveVelocity.y); self.ball.position = GLKVector2Make(self.ball.position.x - self.ball.boundingRect.origin.x, self.ball.position.y); } // right if (self.ball.boundingRect.origin.x + self.ball.boundingRect.size.width >= 320) { self.ball.moveVelocity = GLKVector2Make(-self.ball.moveVelocity.x, self.ball.moveVelocity.y); self.ball.position = GLKVector2Make(self.ball.position.x - (self.ball.boundingRect.size.width + self.ball.boundingRect.origin.x - 320), self.ball.position.y); } // top if (self.ball.boundingRect.origin.y + self.ball.boundingRect.size.height >= 480) { self.ball.moveVelocity = GLKVector2Make(self.ball.moveVelocity.x, -self.ball.moveVelocity.y); self.ball.position = GLKVector2Make(self.ball.position.x, self.ball.position.y - (self.ball.boundingRect.origin.y + self.ball.boundingRect.size.height - 480)); } // bottom (player lose) if (self.ball.boundingRect.origin.y + self.ball.boundingRect.size.height <= 70) { [self endGameWithWin:NO]; } 

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

भागो! गेंद ऊपर से, सही दीवार से उछली - और हम हार गए, हालांकि हमें इसके बारे में पता नहीं था। पहले से ही बुरा नहीं है! अब हमें बल्ले को उछालने की जरूरत है, और, जैसा कि अरकानोइड में प्रथागत है, घटना का कोण हमेशा प्रतिबिंब के कोण के बराबर नहीं होगा, जो गेंद पर बल्ले के गिरने पर निर्भर करेगा। त्रिकोणमिति पहले से ही इस कोण की गणना के लिए यहां लागू है:

  // player strikes! if (CGRectIntersectsRect(self.ball.boundingRect, self.playerBat.boundingRect)) { float angleCoef = (self.ball.position.x - self.playerBat.position.x) / (self.playerBat.contentSize.width / 2); float newAngle = 90.f - angleCoef * 80.f; GLKVector2 ballDirection = GLKVector2Normalize(GLKVector2Make(1 / tanf(GLKMathDegreesToRadians(newAngle)), 1)); float ballSpeed = GLKVector2Length(self.ball.moveVelocity); self.ball.moveVelocity = GLKVector2MultiplyScalar(ballDirection, ballSpeed); self.ball.position = GLKVector2Make(self.ball.position.x, self.ball.position.y + (self.playerBat.boundingRect.origin.y + self.playerBat.boundingRect.size.height - self.ball.boundingRect.origin.y)); } 

आदिम पर्याप्त। लेकिन अब मज़ेदार हिस्सा शुरू होता है: ईंटों के साथ टकराव की परिभाषा, उनका विनाश और गेंद का विद्रोह।

  // checking for broken bricks NSMutableArray *brokenBricks = [NSMutableArray array]; GLKVector2 initialBallVelocity = self.ball.moveVelocity; for (GameSprite *brick in self.bricks) { if (CGRectIntersectsRect(self.ball.boundingRect, brick.boundingRect)) { [brokenBricks addObject: brick]; if ((self.ball.position.y < brick.position.y - brick.contentSize.height / 2) || (self.ball.position.y > brick.position.y + brick.contentSize.height / 2)) { self.ball.moveVelocity = GLKVector2Make(initialBallVelocity.x, -initialBallVelocity.y); } else { self.ball.moveVelocity = GLKVector2Make(-initialBallVelocity.x, initialBallVelocity.y); } } } // removing them for (GameSprite *brick in brokenBricks) { [self.bricks removeObject:brick]; } if (self.bricks.count == 0) { [self endGameWithWin:YES]; } 

यहां तर्क अधिक चालाक है: हम यह निर्धारित करते हैं कि गेंद किस तरफ ईंट से टकराती है, और इसके आधार पर हम गति के आवश्यक घटक को बदलते हैं, और ईंट को टूटी हुई के रूप में चिह्नित करते हैं। ठीक है, तो हम बस सभी टूटे हुए को हटा देते हैं, और अगर कोई भी नहीं बचा है, तो हम खेल खत्म करते हैं, हम जीत गए!

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

 - (void)viewDidLoad { // ... // gestures UIPanGestureRecognizer *panRecognizer = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(handlePanGesture:)]; UITapGestureRecognizer *tapRecognizer = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleTapGestureFrom:)]; [self.view addGestureRecognizer:panRecognizer]; [self.view addGestureRecognizer:tapRecognizer]; } - (void)handleTapGestureFrom:(UITapGestureRecognizer *)recognizer { CGPoint touchLocation = [recognizer locationInView:recognizer.view]; if (self.gameRunning) { GLKVector2 target = GLKVector2Make(touchLocation.x, self.playerBat.position.y); self.playerBat.position = target; } } - (void)handlePanGesture:(UIGestureRecognizer *)gestureRecognizer { CGPoint touchLocation = [gestureRecognizer locationInView:gestureRecognizer.view]; if (self.gameRunning) { GLKVector2 target = GLKVector2Make(touchLocation.x, self.playerBat.position.y); self.playerBat.position = target; } } 

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

 - (void)glkView:(GLKView *)view drawInRect:(CGRect)rect { glClearColor(1.f, 1.f, 1.f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); [self.background render]; [self.playerBat render]; for (GameSprite *brick in self.bricks) { [brick render]; } [self.ball render]; if (!self.gameRunning) { [self.menuDimmer render]; [self.menuStartButton render]; switch (self.gameState) { case kGameStateWon: [self.menuCaptionWon render]; break; case kGameStateLose: [self.menuCaptionLose render]; break; case kGameStateNone: default: [self.menuCaption render]; break; } } } 

यहां, फिर से, सब कुछ बेहद सरल है, मैं टिप्पणी करना भी नहीं चाहता हूं। यह "play" बटन पर क्लिक करने की प्रक्रिया के लिए बना हुआ है, इसके लिए handleTapGestureFrom: "और" ब्लॉक handleTapGestureFrom: :

  else if (CGRectContainsPoint(self.menuStartButton.boundingRect, touchLocation)) { [self startGame]; } 

वह सब है! भागो, खेलो, जीतो और हारो! और सबसे महत्वपूर्ण बात - आनन्द! हम शुद्ध OpenGL पर अपने मूल, स्व-लिखित iPhone गेम में आनन्दित होते हैं!


फूह, सब कुछ लगता है। अब मैं एक ब्रेक ले सकता हूं और मेरे साथ जो हुआ, हमेशा की तरह, गीथूब पर सूत्रों का लिंक दे सकता हूं । (एक चौकस पाठक पहले ही देख चुका है कि गेंद वीडियो में घूमती है; खैर, इसके लिए गिथब पर एक कोड है, लेकिन मैं लेख को अधिभार नहीं देना चाहता था)

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

PS या आगे क्या है:और तब कुछ भी दिलचस्प नहीं था। मैं ZeptoLab में एक साक्षात्कार के लिए गया था, लेकिन बहुत जल्दी एक गहरे स्तर पर OpenGL की अज्ञानता में गिर गया। लेकिन मुझे मेरा लाभ मिला: अब मुझे पता है कि यदि आवश्यक हुआ तो मैं एक सरल खेल बना सकता हूं, और सामान्य तौर पर मुझे अपने लिए एक नए क्षेत्र में थोड़ा पता लगा। मुझे उम्मीद है कि अब आप एक खेल लिख सकते हैं, मेरे प्रिय पाठक भी! सिम के लिए, मुझे अपनी छुट्टी लेने दें, अलविदा।