यह उन लोगों के लिए Pygame का परिचय है जो पहले से ही Python को जानते हैं। यह लेख आपको एक साधारण गेम बनाने के चरण सिखाएगा जिसमें खिलाड़ी उछलती गेंदों को चकमा दे रहा हो।
कदम
८ का भाग १: पायगम स्थापित करना
चरण 1. पायगेम डाउनलोड करें।
इसे अपने प्लेटफॉर्म के लिए https://www.pygame.org/download.shtml से खोजें।
चरण 2. इंस्टॉलर चलाएँ।
चरण 3. सत्यापित करें कि स्थापना ने काम किया।
एक पायथन टर्मिनल खोलें। "आयात पायगम" टाइप करें। यदि आपको कोई त्रुटि दिखाई नहीं देती है तो Pygame को सफलतापूर्वक स्थापित किया गया था।
आयात पायगेम
8 का भाग 2: एक मूल विंडो सेट करना
चरण 1. एक नई फ़ाइल खोलें।
चरण 2. पायगम आयात करें।
पायगेम एक पुस्तकालय है जो ग्राफिक्स कार्यों तक पहुंच प्रदान करता है। यदि आप इन कार्यों के काम करने के तरीके के बारे में अधिक जानकारी चाहते हैं, तो आप उन्हें पायगम वेबसाइट पर देख सकते हैं।
pygame.locals आयात से pygame आयात करें *
चरण 3. विंडो रिज़ॉल्यूशन सेट करें।
आप स्क्रीन रिज़ॉल्यूशन के लिए एक वैश्विक चर बना रहे होंगे ताकि इसे खेल के कई हिस्सों में संदर्भित किया जा सके। फ़ाइल के शीर्ष पर ढूंढना भी आसान है, इसलिए इसे बाद में बदला जा सकता है। उन्नत परियोजनाओं के लिए, इस जानकारी को एक अलग फ़ाइल में रखना एक बेहतर विचार होगा।
संकल्प = (400, 300)
चरण 4. कुछ रंगों को परिभाषित करें।
पायगेम में रंग हैं (आरबीजीए जो 0 और 255 के बीच के मानों में होता है। अल्फा मान (ए) वैकल्पिक है लेकिन अन्य रंग (लाल, नीला और हरा अनिवार्य हैं)।
सफेद = (255, 255, 255) काला = (0, 0, 0) लाल = (255, 0, 0)
चरण 5. स्क्रीन को प्रारंभ करें।
रिज़ॉल्यूशन वैरिएबल का उपयोग करें जिसे पहले परिभाषित किया गया था।
स्क्रीन = pygame.display.set_mode (रिज़ॉल्यूशन)
चरण 6. एक गेम लूप बनाएं।
हमारे खेल के हर फ्रेम में कुछ क्रियाओं को दोहराएं। एक लूप बनाएं जो इन सभी क्रियाओं के माध्यम से हमेशा चक्र को दोहराएगा।
जबकि सच:
चरण 7. स्क्रीन को रंग दें।
स्क्रीन.फिल (सफेद)
चरण 8. स्क्रीन प्रदर्शित करें।
यदि आप प्रोग्राम चलाते हैं, तो स्क्रीन सफेद हो जाएगी और फिर प्रोग्राम क्रैश हो जाएगा। ऐसा इसलिए है क्योंकि ऑपरेटिंग सिस्टम गेम में इवेंट भेज रहा है और गेम उनके साथ कुछ नहीं कर रहा है। एक बार जब गेम को बहुत से हैंडल न किए गए इवेंट मिलते हैं, तो यह क्रैश हो जाएगा।
जबकि ट्रू: … pygame.display.flip()
चरण 9. घटनाओं को संभालें।
प्रत्येक फ्रेम में हुई सभी घटनाओं की एक सूची प्राप्त करें। आप केवल एक घटना, छोड़ने की घटना के बारे में परवाह करने जा रहे हैं। यह तब होता है जब उपयोगकर्ता गेम विंडो बंद कर देता है। यह हमारे कार्यक्रम को बहुत अधिक घटनाओं के कारण क्रैश होने से भी रोकेगा।
जबकि सच: … pygame.event.get() में घटना के लिए: अगर घटना। टाइप == छोड़ो: pygame.quit()
चरण 10. इसे आज़माएं
यहां बताया गया है कि कोड अब कैसा दिखना चाहिए:
pygame.locals से आयात करें आयात * संकल्प = (400, 300) सफेद = (255, 255, 255) काला = (0, 0, 0) लाल = (255, 0, 0) स्क्रीन = pygame.display.set_mode(रिज़ॉल्यूशन) जबकि ट्रू: स्क्रीन.फिल (व्हाइट) pygame.display.flip () pygame.event.get() में इवेंट के लिए: if event.type == QUIT: pygame.quit()
8 का भाग 3: गेम ऑब्जेक्ट बनाना
चरण 1. एक नया वर्ग और निर्माता बनाएं।
वस्तु के सभी गुण सेट करें। आप सभी संपत्तियों के लिए डिफ़ॉल्ट मान भी प्रदान कर रहे हैं।
क्लास बॉल: def _init_ (स्वयं, xPos = संकल्प [0] / 2, yPos = संकल्प [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "बॉल"
चरण 2. परिभाषित करें कि वस्तु को कैसे खींचना है।
गेंद को एक सर्कल के रूप में खींचने के लिए और साथ ही ऑब्जेक्ट को आकर्षित करने के लिए फ़ंक्शन में सतह को पास करने के लिए कंस्ट्रक्टर में परिभाषित गुणों का उपयोग करें। सतह स्क्रीन ऑब्जेक्ट होगी जिसे पहले रिज़ॉल्यूशन का उपयोग करके बनाया गया था।
def ड्रा (स्वयं, सतह): pygame.draw.circle (सतह, काला, (self.x, self.y), self.radius)
चरण 3. कक्षा का एक उदाहरण बनाएं और साथ ही खेल लूप को प्रत्येक लूप में गेंद खींचने के लिए कहें।
बॉल = बॉल () जबकि ट्रू: … बॉल.ड्रा (स्क्रीन)
चरण 4. वस्तु को गतिमान करें।
एक फ़ंक्शन बनाएं जो ऑब्जेक्ट की स्थिति को अपडेट करेगा। इस फ़ंक्शन को प्रत्येक गेम लूप में कॉल करें।
क्लास बॉल: … डीईएफ़ अपडेट (सेल्फ): सेल्फ.एक्स += सेल्फ.डीएक्स सेल्फ.वाई += सेल्फ.डी
चरण 5. फ्रेम दर को सीमित करें।
गेंद वास्तव में तेजी से आगे बढ़ेगी क्योंकि गेम लूप एक सेकंड में सैकड़ों बार चल रहा है। फ्रेम दर को 60 fps तक सीमित करने के लिए Pygame की घड़ी का उपयोग करें।
घड़ी = pygame.time. Clock () जबकि सच: … घड़ी.टिक (60)
चरण 6. गेंद को स्क्रीन पर रखें।
यदि गेंद स्क्रीन के किसी एक किनारे से टकराती है तो गेंद की दिशा को उलटने के लिए अपडेट फ़ंक्शन में चेक जोड़ें।
क्लास बॉल: … डीईएफ़ अपडेट (सेल्फ): … अगर (सेल्फ.एक्स <= 0 या सेल्फ.एक्स>= रेजोल्यूशन [0]): सेल्फ.डीएक्स *= -1 अगर (सेल्फ.वाई <= 0 या सेल्फ.वाई >= संकल्प [1]): self.dy *= -1
चरण 7. इसे आज़माएं
यहां बताया गया है कि कोड अब कैसा दिखना चाहिए:
pygame.locals से आयात करें आयात * संकल्प = (400, 300) सफेद = (255, 255, 255) काला = (0, 0, 0) लाल = (255, 0, 0) स्क्रीन = pygame.display.set_mode(संकल्प) वर्ग गेंद: def _init_(स्वयं, xPos = संकल्प [0] / 2, yPos = संकल्प [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" def draw(self, Surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def अद्यतन (स्वयं): self.x += self.dx self.y += self.dy अगर (self.x <= 0 या self.x >= संकल्प [0]): self.dx *= -1 अगर (self.y <= 0 या self.y>= संकल्प [1]): self.dy *= -1 बॉल = बॉल () क्लॉक = pygame.time. Clock() जबकि ट्रू: स्क्रीन। pygame.event.get() में ईवेंट के लिए fill(white) ball.draw(screen) ball.update() pygame.display.flip() clock.tick(60): if event.type == QUIT: pygame.quit ()
8 का भाग 4: खेल का आयोजन
चरण 1. सब कुछ व्यवस्थित करने के लिए कक्षाओं का उपयोग करें।
खेल और जटिल होता जा रहा है। अपने कोड को व्यवस्थित करने के लिए ऑब्जेक्ट-ओरिएंटेड तकनीकों का उपयोग करें।
चरण 2. गेम लूप को एक कक्षा में बनाएं।
चूंकि हमारे गेम में अब आपके गेम ऑब्जेक्ट्स और फ़ंक्शंस सहित डेटा है, इसलिए आपके गेम लूप को क्लास में बदलना समझ में आता है।
क्लास गेम ():
चरण 3. एक कंस्ट्रक्टर जोड़ें।
यहां आप कुछ गेम ऑब्जेक्ट्स को इंस्टेंट करेंगे, हमारी स्क्रीन और क्लॉक बनाएंगे और Pygame को इनिशियलाइज़ करेंगे। पाठ या ध्वनि जैसी कुछ विशेषताओं का उपयोग करने के लिए Pygame को प्रारंभ करने की आवश्यकता है।
क्लास गेम (): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution) self.clock = pygame.time. Clock()
चरण 4. एक समारोह में घटनाओं को संभालें।
क्लास गेम (): … डीईएफ़ हैंडलइवेंट्स (सेल्फ): pygame.event.get () में इवेंट के लिए: अगर इवेंट। टाइप == QUIT: pygame.quit ()
चरण 5. गेम लूप को एक फंक्शन बनाएं।
प्रत्येक लूप में ईवेंट हैंडलिंग फ़ंक्शन को कॉल करें।
क्लास गेम (): … डिफ रन (सेल्फ): जबकि ट्रू: सेल्फ.हैंडलइवेंट्स () सेल्फ.स्क्रीन.फिल (व्हाइट) सेल्फ.क्लॉक.टिक (60) pygame.display.flip()
चरण 6. कई खेल वस्तुओं को संभालें।
अभी इस कोड को ड्रॉ को कॉल करना है और प्रत्येक फ्रेम पर हमारे ऑब्जेक्ट पर अपडेट करना है। यदि आपके पास बहुत सारी वस्तुएं हों तो यह गड़बड़ हो जाएगा। आइए अपनी वस्तु को एक सरणी में जोड़ें और फिर प्रत्येक लूप में सरणी में सभी वस्तुओं को अपडेट और ड्रा करें। अब आप आसानी से एक और वस्तु जोड़ सकते हैं और इसे एक अलग प्रारंभिक स्थिति दे सकते हैं।
क्लास गेम (): def _init_(self):… self.gameObjects = self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) … def run(self): जबकि True: self.handleEvents() for gameObj in self.gameObjects: gameObj.update() self.screen.fill(white) for gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display फ्लिप ()
चरण 7. इसे आज़माएं
यहां बताया गया है कि कोड अब कैसा दिखना चाहिए:
pygame.locals से आयात करें आयात * संकल्प = (400, 300) सफेद = (255, 255, 255) काला = (0, 0, 0) लाल = (255, 0, 0) स्क्रीन = pygame.display.set_mode(संकल्प) वर्ग गेंद: def _init_(स्वयं, xPos = संकल्प [0] / 2, yPos = संकल्प [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" def draw(self, Surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def अद्यतन (स्वयं): self.x += self.dx self.y += self.dy अगर (self.x <= 0 या self.x >= संकल्प [0]): self.dx *= -1 अगर (self.y <= 0 या self.y >= संकल्प [1]): self.dy *= -1 क्लास गेम (): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) def handleEvents(स्वयं): pygame.event.get () में घटना के लिए: यदि घटना। प्रकार == छोड़ो: pygame.quit() def रन (स्वयं): जबकि सच: self.handleEvent s() गेमऑब्ज के लिए self.gameऑब्जेक्ट्स: gameObj.update() self.screen.fill(white) for gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display। फ्लिप () गेम ()। रन ()
८ का भाग ५: प्लेयर ऑब्जेक्ट जोड़ना
चरण 1. एक खिलाड़ी वर्ग और निर्माता बनाएं।
आप एक और सर्कल बनाने जा रहे हैं जिसे माउस द्वारा नियंत्रित किया जाता है। कंस्ट्रक्टर में मानों को इनिशियलाइज़ करें। त्रिज्या एकमात्र महत्वपूर्ण मूल्य है।
क्लास प्लेयर: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
चरण 2. परिभाषित करें कि प्लेयर ऑब्जेक्ट कैसे ड्रा करें।
यह वैसे ही होगा जैसे आपने अन्य गेम ऑब्जेक्ट्स को आकर्षित किया था।
क्लास प्लेयर: … डीईएफ़ ड्रा (सेल्फ, सरफेस): pygame.draw.circle (सतह, लाल, (सेल्फ.एक्स, सेल्फ.वाई), सेल्फ.रेडियस)
चरण 3. प्लेयर ऑब्जेक्ट के लिए माउस नियंत्रण जोड़ें।
प्रत्येक फ्रेम में, माउस के स्थान की जाँच करें और खिलाड़ियों की वस्तुओं के स्थान को उस बिंदु पर सेट करें।
क्लास प्लेयर: … डीईएफ़ अपडेट (सेल्फ): कॉर्ड = pygame.mouse.get_pos () self.x = कॉर्ड [0] self.y = कॉर्ड[1]
चरण 4. गेमऑब्जेक्ट में प्लेयर ऑब्जेक्ट जोड़ें।
एक नया प्लेयर इंस्टेंस बनाएं और इसे सूची में जोड़ें।
क्लास गेम (): def _init_(self): … self.gameObjects.append(Player ())
चरण 5. इसे आज़माएं
यहां बताया गया है कि कोड अब कैसा दिखना चाहिए:
pygame.locals से आयात करें आयात * संकल्प = (400, 300) सफेद = (255, 255, 255) काला = (0, 0, 0) लाल = (255, 0, 0) स्क्रीन = pygame.display.set_mode(संकल्प) वर्ग गेंद: def _init_(स्वयं, xPos = संकल्प [0] / 2, yPos = संकल्प [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" def draw(self, Surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def अद्यतन (स्वयं): self.x += self.dx self.y += self.dy अगर (self.x <= 0 या self.x >= संकल्प [0]): self.dx *= -1 अगर (self.y <= 0 या self.y >= संकल्प [1]): self.dy *= -1 वर्ग खिलाड़ी: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "खिलाड़ी" def ड्रा (सेल्फ, सरफेस): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def अद्यतन (स्व): कॉर्ड = pygame.mouse.get_pos() self.x = कॉर्ड [0] self.y = कॉर्ड [1] क्लास गेम (): def _init_(self): pygame.init() self.screen = pygame.प्रदर्शन.सेट_ मोड (रिज़ॉल्यूशन) सेल्फ.क्लॉक = pygame.time. Clock () सेल्फ.गेमऑब्जेक्ट्स = सेल्फ.गेमऑब्जेक्ट्स.एपेंड (प्लेयर ()) सेल्फ.गेमऑब्जेक्ट्स.एपेंड (बॉल ()) सेल्फ.गेमऑब्जेक्ट्स.एपेंड (बॉल (100))) def handleEvents(self): pygame.event.get() में ईवेंट के लिए: if event.type == QUIT: pygame.quit() def run(self): जबकि True: self.handleEvents() gameObj के लिए स्वयं में.gameObjects: gameObj.update() self.screen.fill(white) for gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game()। Daud()
८ का भाग ६: खिलाड़ी के साथ वस्तुओं का आदान-प्रदान करना
चरण 1. अद्यतन फ़ंक्शन बदलें।
वस्तुओं को परस्पर क्रिया करने के लिए, उन्हें एक दूसरे तक पहुँच की आवश्यकता होगी। गेमऑब्जेक्ट्स सूची में पास करने के लिए अपडेट में एक और पैरामीटर जोड़ें। आपको इसे प्लेयर ऑब्जेक्ट और बॉल ऑब्जेक्ट दोनों में जोड़ना होगा। यदि आपके पास बहुत सारी गेम ऑब्जेक्ट हैं, तो इनहेरिटेंस आपको अपने सभी मेथड सिग्नेचर को समान रखने में मदद कर सकता है।
क्लास बॉल: … डीईएफ़ अपडेट (सेल्फ, गेमऑब्जेक्ट्स): … क्लास प्लेयर: … डीईएफ़ अपडेट (सेल्फ, गेमऑब्जेक्ट्स):
चरण 2. खिलाड़ी और गेंदों के बीच टकराव की जाँच करें।
सभी खेल वस्तुओं को देखें और जांचें कि क्या वस्तुओं का प्रकार गेंद है। फिर दो वस्तुओं की त्रिज्या और दूरी सूत्र का उपयोग करके जाँच करें कि क्या वे टकरा रही हैं। मंडलियों पर टकराव की जाँच करना वास्तव में आसान है। यह सबसे बड़ा कारण है कि आपने इस खेल के लिए किसी अन्य आकार का उपयोग नहीं किया।
क्लास प्लेयर: … डीईएफ़ अपडेट (सेल्फ, गेमऑब्जेक्ट्स): … गेमऑब्जेक्ट में गेमऑब्ज के लिए: अगर गेमऑब्ज.टाइप == "बॉल": अगर (गेमऑब्ज.एक्स - सेल्फ.एक्स)**2 + (गेमऑब्ज.)**2 <= (gameObj.radius + self.radius)**2:
चरण 3. यदि खिलाड़ी "हिट" हो जाता है तो खेल समाप्त करें।
आइए अभी के लिए खेल छोड़ दें।
if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: pygame.quit()
चरण 4. इसे आज़माएं
यहां बताया गया है कि कोड अब कैसा दिखना चाहिए:
pygame.locals से आयात करें आयात * संकल्प = (400, 300) सफेद = (255, 255, 255) काला = (0, 0, 0) लाल = (255, 0, 0) स्क्रीन = pygame.display.set_mode(संकल्प) वर्ग गेंद: def _init_(स्वयं, xPos = संकल्प [0] / 2, yPos = संकल्प [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" def draw(self, Surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def अद्यतन (स्वयं, gameObjects): self.x += self.dx self.y += self.dy अगर (self.x <= 0 या self.x >= संकल्प [0]): स्वयं.dx *= -1 अगर (self.y <= 0 या self.y >= संकल्प [1]): self.dy *= -1 वर्ग खिलाड़ी: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "खिलाड़ी" def ड्रा (सेल्फ, सरफेस): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def अद्यतन (स्वयं, gameObjects): कॉर्ड = pygame.mouse.get_pos() self.x = कॉर्ड [0] self.y = कॉर्ड [1] गेमऑब्जेक्ट में गेमऑब्ज के लिए: यदि गेमऑब्ज.टाइप == "बॉल": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: pygame.quit() क्लास गेम (): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Player()) self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) def handleEvents(self): pygame.event.get() में इवेंट के लिए: if event.type == QUIT: pygame.quit () डिफ रन (सेल्फ): जबकि ट्रू: सेल्फ.हैंडलइवेंट्स () गेमऑब्ज इन सेल्फ.गेमऑब्जेक्ट्स: गेमऑब्ज.अपडेट (सेल्फ.गेमऑब्जेक्ट्स) सेल्फ.स्क्रीन.फिल (व्हाइट) फॉर गेमऑब्ज इन सेल्फ.गेमऑब्जेक्ट्स: गेमऑब्ज.ड्रा(self.screen) self.clock.tick(60) pygame.display.flip() game().run()
8 का भाग 7: ऑब्जेक्ट बनाने के लिए गेम कंट्रोलर जोड़ना
चरण 1. गेम कंट्रोलर क्लास बनाएं।
गेम कंट्रोलर गेम को "रनिंग" करने के लिए जिम्मेदार होते हैं। यह हमारे खेल वर्ग से अलग है जो हमारी सभी वस्तुओं को चित्रित करने और अद्यतन करने के लिए जिम्मेदार है। खेल को कठिन बनाने के लिए नियंत्रक समय-समय पर स्क्रीन पर एक और गेंद जोड़ देगा। एक कंस्ट्रक्टर जोड़ें और कुछ बुनियादी मूल्यों को इनिशियलाइज़ करें। अंतराल एक और गेंद जोड़े जाने से पहले का समय होगा।
क्लास गेमकंट्रोलर: def _init_ (सेल्फ, इंटरवल = 5): सेल्फ.इंटर = इंटरवल सेल्फ.नेक्स्ट = pygame.time.get_ticks () + (2 * 1000) सेल्फ.टाइप = "गेम कंट्रोलर"
चरण 2. अद्यतन फ़ंक्शन जोड़ें।
यह जाँच करेगा कि गेंद को जोड़े जाने के बाद या खेल की शुरुआत से कितना समय बीत चुका है। यदि समय अंतराल से अधिक है तो आप समय को रीसेट करेंगे और एक गेंद जोड़ेंगे।
क्लास गेमकंट्रोलर: … डीईएफ़ अपडेट (सेल्फ, गेमऑब्जेक्ट्स): अगर सेल्फ.नेक्स्ट < pygame.time.get_ticks (): सेल्फ.नेक्स्ट = pygame.time.get_ticks () + (सेल्फ.इंटर * 1000) गेमऑब्जेक्ट्स। एपेंड (बॉल (बॉल)))
चरण 3. गेंदों को यादृच्छिक वेग दें।
खेल को हर बार अलग बनाने के लिए आपको यादृच्छिक संख्याओं का उपयोग करना होगा। हालाँकि, गेंदों का वेग अब एक पूर्णांक के बजाय एक अस्थायी बिंदु संख्या है।
क्लास गेमकंट्रोलर: … डीईएफ़ अपडेट (सेल्फ, गेमऑब्जेक्ट्स): अगर सेल्फ.नेक्स्ट < pygame.time.get_ticks (): सेल्फ.नेक्स्ट = pygame.time.get_ticks () + (सेल्फ.इंटर * 1000) गेमऑब्जेक्ट्स। एपेंड (बॉल (बॉल) xVel=random()*2, yVel=random()*2))
चरण 4. ड्रा फ़ंक्शन को ठीक करें।
ड्रा फ़ंक्शन फ़्लोट स्वीकार नहीं करेगा। आइए गेंदों को खींचे जाने से पहले गेंद की स्थिति को पूर्णांक में बदलें।
क्लास बॉल: … def ड्रा (सेल्फ, सरफेस): pygame.draw.circle (सतह, काला, (int(self.x), int(self.y)), self.radius)
चरण 5. गेम कंट्रोलर के लिए ड्रा विधि को परिभाषित करें।
चूंकि यह एक गेम ऑब्जेक्ट है, मुख्य लूप इसे खींचने का प्रयास करेगा। आपको ड्रॉ फ़ंक्शन को परिभाषित करने की आवश्यकता होगी जो कुछ भी नहीं करता है ताकि गेम क्रैश न हो।
क्लास गेमकंट्रोलर: … डीईएफ़ ड्रॉ (सेल्फ, स्क्रीन): पास
चरण 6. गेम कंट्रोलर को गेमऑब्जेक्ट में जोड़ें और 2 गेंदों को हटा दें।
खेल को अब हर पांच सेकंड में एक गेंद को स्पॉन करना चाहिए।
वर्ग खेल (): def _init_ (स्वयं): … self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (खिलाड़ी ())
चरण 7. इसे आज़माएं
यहां बताया गया है कि कोड अब कैसा दिखना चाहिए:
pygame.locals से यादृच्छिक आयात से pygame आयात करें। आयात * संकल्प = (400, 300) सफेद = (255, 255, 255) काला = (0, 0, 0) लाल = (255, 0, 0) स्क्रीन = pygame. display.set_mode(resolution) वर्ग गेंद: def _init_(self, xPos = संकल्प [0] / 2, yPos = संकल्प [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "बॉल" def ड्रा (सेल्फ, सरफेस): pygame.draw.circle (सतह, काला, (int(self. x), int(self.y)), self.radius) def update(self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 or self. x >= संकल्प [0]): self.dx *= -1 अगर (self.y <= 0 या self.y >= संकल्प [1]): self.dy *= -1 वर्ग खिलाड़ी: def _init_(self, रेड = 20): सेल्फ़.एक्स = 0 सेल्फ़.वाई = 0 सेल्फ़.रेडियस = रेड सेल्फ़.टाइप = "प्लेयर" डीफ़ ड्रॉ (सेल्फ, सरफेस): pygame.draw.circle (सतह, रेड, (सेल्फ.एक्स), self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] गेम में gameObj के लिए ऑब्जेक्ट: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)* *2: pygame.quit() क्लास गेमकंट्रोलर: def _init_(self, इंटरवल = 5): self.inter = इंटरवल सेल्फ.नेक्स्ट = pygame.time.get_ticks() + (2 * 1000) self.type = "गेम कंट्रोलर "डीईएफ़ अपडेट (सेल्फ, गेमऑब्जेक्ट्स): अगर सेल्फ.नेक्स्ट < pygame.time.get_ticks(): self.next = pygame.time.get_ticks() + (self.inter * 1000) gameObjects.append(Ball(xVel=random) ()*2, yVel=random()*2)) def ड्रा (सेल्फ, स्क्रीन): पास क्लास गेम (): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution)) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player()) def handleEvents(self): pygame.event में इवेंट के लिए.get(): if event.type == QUIT: pygame.quit() def run(self): जबकि True: self.handleEvents() for gameObj in self.gameObjects: gameObj.update(self.gameObjects) self.screen.fill(सफेद) gameObj in self.gameO. के लिए ऑब्जेक्ट्स: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game().run()
8 का भाग 8: एक अंक जोड़ना और खेल खत्म करना
चरण 1. खेल नियंत्रक वर्ग में एक अंक जोड़ें।
एक फॉन्ट ऑब्जेक्ट और एक स्कोर वेरिएबल बनाएं। आप स्कोर प्रदर्शित करने के लिए हर फ्रेम में फॉन्ट खींचेंगे और अपडेट में हर फ्रेम में स्कोर बढ़ाएंगे।
क्लास गेमकंट्रोलर: डीईएफ़ _init_ (सेल्फ, इंटरवल = 5): … सेल्फ.स्कोर = 0 सेल्फ.स्कोरटेक्स्ट = pygame.font. Font (कोई नहीं, 12) डीईएफ़ अपडेट (सेल्फ, गेमऑब्जेक्ट्स): … सेल्फ.स्कोर + = 1 डीईएफ़ ड्रा (स्वयं, स्क्रीन): Screen.blit(self.scoreText.render(str(self.score), ट्रू, ब्लैक), (5, 5))
चरण 2. संशोधित करें कि खेल कैसे समाप्त होता है।
जब खिलाड़ी को टक्कर का पता चलता है, तो आइए छोड़ें से छुटकारा पाएं। इसके बजाय आप प्लेयर में एक वैरिएबल सेट करेंगे जिसे गेम चेक कर सकता है। जब गेमओवर सेट हो, तो ऑब्जेक्ट को अपडेट करना बंद करें। यह सब कुछ स्थिर कर देगा ताकि खिलाड़ी देख सके कि क्या हुआ और अपने स्कोर की जांच करें। ध्यान दें कि ऑब्जेक्ट अभी भी खींचे जा रहे हैं, बस अपडेट नहीं किए गए हैं।
क्लास प्लेयर: def _init_(self, rad = 20):… self.gameOver = False def update(self, gameObjects): … gameObj के लिए gameObjects: if gameObj.type == "ball": if (gameObj.x - self).x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: self.gameOver = ट्रू क्लास गेम (): def _init_(self): … self.gameOver = False def run(self): जबकि True: self.handleEvents() if नहीं self.gameOver: gameObj in self.gameObjects: gameObj.update(self.gameObjects) if gameObj.type == "player": self.gameOver = gameObj.gameOver
चरण 3. इसे आज़माएं
यहां बताया गया है कि तैयार कोड अब कैसा दिखना चाहिए:
pygame.locals आयात से यादृच्छिक आयात से pygame आयात करें * संकल्प = (400, 300) सफेद = (255, 255, 255) काला = (0, 0, 0) लाल = (255, 0, 0) स्क्रीन = pygame. display.set_mode(resolution) वर्ग गेंद: def _init_(self, xPos = संकल्प [0] / 2, yPos = संकल्प [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "ball" def draw(self, Surface): pygame.draw.circle(surface, black, (int(self. x), int(self.y)), self.radius) def update(self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 or self. x >= संकल्प [0]): self.dx *= -1 अगर (self.y <= 0 या self.y >= संकल्प [1]): self.dy *= -1 वर्ग खिलाड़ी: def _init_(self, रेड = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "खिलाड़ी" self.gameOver = झूठा def ड्रा (स्व, सतह): pygame.draw.circle (सतह, लाल, (self.x, self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] गेमऑब्जेक्ट्स में गेमऑब्ज के लिए: अगर गेमऑब्ज.टाइप == "बॉल": अगर (गेमऑब्ज.एक्स - सेल्फ.एक्स)**2 + (गेमऑब्ज.वाई - सेल्फ.वाई)**2 <= (गेमऑब्ज.रेडियस + self.radius)**2: self.gameOver = ट्रू क्लास गेमकंट्रोलर: def _init_ (सेल्फ, इंटरवल = 5): सेल्फ.इंटर = इंटरवल सेल्फ.नेक्स्ट = pygame.time.get_ticks() + (2 * 1000) सेल्फ। टाइप = "गेम कंट्रोलर" सेल्फ.स्कोर = 0 सेल्फ.स्कोरटेक्स्ट = pygame.font. Font (कोई नहीं, 12) डीईएफ़ अपडेट (सेल्फ, गेमऑब्जेक्ट्स): अगर सेल्फ.नेक्स्ट < pygame.time.get_ticks (): self.next = pygame.time.get_ticks() + (self.inter * 1000) gameObjects.append(Ball(xVel=random()*2, yVel=random()*2)) self.score += 1 def draw(self, Screen): Screen.blit(self.scoreText.render(str(self.score), ट्रू, ब्लैक), (5, 5)) क्लास गेम (): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(resolution) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player()) self.gameOver = False def हैंडलइवेंट्स (स्वयं): pygame.event.get () में घटना के लिए: यदि ev ent.type == QUIT: pygame.quit() def run(self): जबकि True: self.handleEvents() if नहीं self.gameOver: gameObj के लिए self.gameObjects: gameObj.update(self.gameObjects) if gameObj. type == "खिलाड़ी": self.gameOver = gameObj.gameOver self.screen.fill(white) gameObj in self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip () खेल ()। रन ()
