अजगर का उपयोग करके पायथन में एक प्लेटफ़ॉर्मर लिखना

मुझे तुरंत कहना चाहिए कि सबसे छोटे शुरुआती लोगों के लिए यहां क्या लिखा गया है।

मैं लंबे समय से खुद को गेम मेकर के रूप में आजमाना चाहता था और हाल ही में मुझे पायथन सीखने और एक पुराने सपने को पूरा करने का अवसर मिला।

एक platformer क्या है?

प्लेटफ़ॉर्मर (प्लेटफ़ॉर्मर) - कंप्यूटर गेम की एक शैली जिसमें गेमप्ले की मुख्य विशेषता प्लेटफार्मों पर कूदना, सीढ़ियां चढ़ना, उन वस्तुओं को इकट्ठा करना है जो आमतौर पर स्तर को पूरा करने के लिए आवश्यक होती हैं।
विकी

इस शैली के मेरे पसंदीदा खेलों में से एक सुपर मारियो ब्रदर्स और सुपर मीट बॉय हैं। चलो बीच में कुछ बनाने की कोशिश करते हैं।

सबसे बहुत शुरुआत है।

चेतावनी! हम अजगर शाखाओं का उपयोग करते हैं 2.x, 3.x के साथ हमें नीचे वर्णित लिपियों को चलाने में समस्याओं का सामना करना पड़ा है!

शायद, न केवल खेल, लेकिन pygame का उपयोग करने वाले सभी एप्लिकेशन इस तरह से शुरू होते हैं:

#!/usr/bin/env python # -*- coding: utf-8 -*- #   pygame import pygame from pygame import * #  WIN_WIDTH = 800 #   WIN_HEIGHT = 640 #  DISPLAY = (WIN_WIDTH, WIN_HEIGHT) #        BACKGROUND_COLOR = "#004400" def main(): pygame.init() #  PyGame,   screen = pygame.display.set_mode(DISPLAY) #   pygame.display.set_caption("Super Mario Boy") #    bg = Surface((WIN_WIDTH,WIN_HEIGHT)) #    #     bg.fill(Color(BACKGROUND_COLOR)) #     while 1: #    for e in pygame.event.get(): #   if e.type == QUIT: raise SystemExit, "QUIT" screen.blit(bg, (0,0)) #      pygame.display.update() #        if __name__ == "__main__": main() 

खेल एक लूप ("1) में" स्पिन "करेगा, प्रत्येक पुनरावृत्ति को सब कुछ (पृष्ठभूमि, प्लेटफार्मों, राक्षसों, डिजिटल संदेशों, आदि) को फिर से तैयार करना होगा।" यह ध्यान रखना महत्वपूर्ण है कि ड्राइंग अनुक्रमिक है, अर्थात। यदि आप पहले एक नायक को आकर्षित करते हैं, और फिर पृष्ठभूमि में भरते हैं, तो नायक दिखाई नहीं देगा, भविष्य के लिए इसे ध्यान में रखें।

इस कोड को चलाने पर, हम हरे रंग से भरी एक विंडो देखेंगे।


(छवि क्लिक करने योग्य है)

ठीक है, शुरुआत की गई है, चलो आगे बढ़ते हैं।

स्तर।

और उसके बिना कैसे? शब्द "स्तर" से हमारा तात्पर्य किसी भी सामान से भरे एक आभासी दो-आयामी स्थान का एक सीमित क्षेत्र है, और जिसके साथ हमारा चरित्र आगे बढ़ेगा।

स्तर बनाने के लिए, n द्वारा द्वि-आयामी सरणी m बनाएँ। प्रत्येक कोशिका (m, n) एक आयत होगी। एक आयत अपने आप में कुछ हो सकता है, या यह खाली हो सकता है। हम आयतों में प्लेटफॉर्म तैयार करेंगे।

अधिक स्थिरांक जोड़ें

 PLATFORM_WIDTH = 32 PLATFORM_HEIGHT = 32 PLATFORM_COLOR = "#FF6262" 

फिर मुख्य फ़ंक्शन में एक स्तर की घोषणा जोड़ें

 level = [ "-------------------------", "- -", "- -", "- -", "- -- -", "- -", "-- -", "- -", "- --- -", "- -", "- -", "- --- -", "- -", "- ----------- -", "- -", "- - -", "- -- -", "- -", "- -", "-------------------------"] 

और मुख्य लूप में, निम्नलिखित जोड़ें:

 x=y=0 #  for row in level: #   for col in row: #   if col == "-": # ,       pf = Surface((PLATFORM_WIDTH,PLATFORM_HEIGHT)) pf.fill(Color(PLATFORM_COLOR)) screen.blit(pf,(x,y)) x += PLATFORM_WIDTH #      y += PLATFORM_HEIGHT #      x = 0 #       

यानी हम दो-आयामी सरणी स्तर पर पुनरावृत्ति करते हैं, और यदि हमें प्रतीक "-" मिलता है, तो निर्देशांक पर (x * PLATFORM_WIDTH, y * PLATFORM_HEIGHT), जहां x, y समतल सरणी में सूचकांक है

चल रहा है, हम निम्नलिखित देखेंगे:

चरित्र

पृष्ठभूमि में बस क्यूब्स बहुत उबाऊ हैं। हमें अपने चरित्र की आवश्यकता है जो प्लेटफार्मों पर चले और कूदें।

हम अपने नायक का एक वर्ग बनाते हैं।

सुविधा के लिए, हम अपने चरित्र को एक अलग प्लेयर - थ्रू फ़ाइल में रखेंगे

 #!/usr/bin/env python # -*- coding: utf-8 -*- from pygame import * MOVE_SPEED = 7 WIDTH = 22 HEIGHT = 32 COLOR = "#888888" class Player(sprite.Sprite): def __init__(self, x, y): sprite.Sprite.__init__(self) self.xvel = 0 # . 0 -    self.startX = x #   ,      self.startY = y self.image = Surface((WIDTH,HEIGHT)) self.image.fill(Color(COLOR)) self.rect = Rect(x, y, WIDTH, HEIGHT) #   def update(self, left, right): if left: self.xvel = -MOVE_SPEED #  = x- n if right: self.xvel = MOVE_SPEED #  = x + n if not(left or right): # ,     self.xvel = 0 self.rect.x += self.xvel #     xvel def draw(self, screen): #     screen.blit(self.image, (self.rect.x,self.rect.y)) 

क्या दिलचस्प है?
शुरू करने के लिए, हम एक नई कक्षा बनाते हैं, जो कि pygame.sprite.Sprite वर्ग से विरासत में मिली, जिससे स्प्राइट की सभी विशेषताओं को विरासत में मिला।
स्प्राइट एक गतिमान बिटमैप है। इसमें कई उपयोगी तरीके और गुण हैं।

self.rect = Rect (x, y, WIDTH, HEIGHT) , इस पंक्ति में हम अपने चरित्र की वास्तविक सीमाओं को बनाते हैं, एक आयत जिसके साथ हम न केवल नायक को स्थानांतरित करेंगे, बल्कि टक्करों की भी जांच करेंगे। लेकिन इसके बारे में और नीचे।

अद्यतन (स्वयं, बाएं, दाएं) विधि का उपयोग किसी वस्तु के व्यवहार का वर्णन करने के लिए किया जाता है। अभिभावक अद्यतन (* args) -> कोई नहीं । स्प्राइट समूहों में बुलाया जा सकता है।

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

हमारे नायक को कार्यक्रम के मुख्य भाग में जोड़ें।

स्तर का निर्धारण करने से पहले, हम नायक की परिभाषा और उसके आंदोलन के चर को जोड़ते हैं।

 hero = Player(55,55) #    (x,y)  left = right = False #   —  

ईवेंट जाँच में, निम्नलिखित जोड़ें:

 if e.type == KEYDOWN and e.key == K_LEFT: left = True if e.type == KEYDOWN and e.key == K_RIGHT: right = True if e.type == KEYUP and e.key == K_RIGHT: right = False if e.type == KEYUP and e.key == K_LEFT: left = False 

यानी यदि आप बाईं कुंजी दबाते हैं, तो बाएं जाएं। यदि जारी किया जाता है, तो हम रुक जाते हैं। सही बटन के साथ भी

इस आंदोलन को ही इस तरह कहा जाता है: (पृष्ठभूमि और प्लेटफार्मों को फिर से जोड़ने के बाद)

 hero.update(left, right) #  hero.draw(screen) #  

लेकिन, जैसा कि हम देखते हैं, हमारा ग्रे ब्लॉक बहुत तेज़ी से आगे बढ़ता है, हम प्रति सेकंड फ़्रेम की संख्या में एक सीमा जोड़ते हैं। ऐसा करने के लिए, स्तर निर्धारित करने के बाद, एक टाइमर जोड़ें

 timer = pygame.time.Clock() 

और मुख्य लूप की शुरुआत में, निम्नलिखित जोड़ें:

 timer.tick(60) 

हवा में लटक रहा है

हां, हमारा नायक एक निराशाजनक स्थिति में है, वह हवा में मँडरा रहा है।
गुरुत्वाकर्षण और कूदने की क्षमता जोड़ें।

और इसलिए, हम खिलाड़ी के लिए काम करते हैं फ़ाइल

अधिक स्थिरांक जोड़ें

 JUMP_POWER = 10 GRAVITY = 0.35 # ,      

लाइनों को _init_ विधि में जोड़ें:

  self.yvel = 0 #    self.onGround = False #    ? 

अद्यतन विधि में एक इनपुट तर्क जोड़ें
डीईएफ़ अपडेट (स्वयं, बाएँ, दाएँ, ऊपर):
और विधि जोड़ने की शुरुआत में:

 if up: if self.onGround: # ,       self.yvel = -JUMP_POWER 

और लाइन से पहले self.rect.x + = self.xvel
जोड़ा जा रहा है

 if not self.onGround: self.yvel += GRAVITY self.onGround = False; #   ,    (( self.rect.y += self.yvel 

और कार्यक्रम के मुख्य भाग में जोड़ें:
पंक्ति के बाद बाएँ = दाएँ = गलत
चर को जोड़ें

 up = false 

घटना की जाँच में जोड़ें

 if e.type == KEYDOWN and e.key == K_UP: up = True if e.type == KEYUP and e.key == K_UP: up = False 

और नया अप तर्क जोड़कर कॉल को अपडेट विधि में बदलें:
हीरो। चुप (बाएं, दाएं )
पर

 hero.update(left, right, up) 

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

अपनी जमीन पर दोनों पैरों के साथ खड़े रहें।

कैसे पता चलेगा कि हम जमीन या अन्य ठोस सतह पर हैं? उत्तर स्पष्ट है - चौराहे के लिए चेक का उपयोग करें, लेकिन इसके लिए हम प्लेटफार्मों के निर्माण को बदल देंगे।

एक और blocks.py फ़ाइल बनाएं और प्लेटफ़ॉर्म विवरण को उसमें स्थानांतरित करें।

 PLATFORM_WIDTH = 32 PLATFORM_HEIGHT = 32 PLATFORM_COLOR = "#FF6262" 

इसके बाद, pygame.sprite.Sprite से विरासत में एक वर्ग बनाएं

 class Platform(sprite.Sprite): def __init__(self, x, y): sprite.Sprite.__init__(self) self.image = Surface((PLATFORM_WIDTH, PLATFORM_HEIGHT)) self.image.fill(Color(PLATFORM_COLOR)) self.rect = Rect(x, y, PLATFORM_WIDTH, PLATFORM_HEIGHT) 

ऐसा कुछ नहीं है जिससे हम परिचित नहीं हैं, हम आगे बढ़ते हैं।

मुख्य फ़ाइल में, स्तर सरणी के विवरण से पहले परिवर्तन करें, जोड़ें

 entities = pygame.sprite.Group() #   platforms = [] # ,        entities.add(hero) 

इस समूह के सभी तत्वों को प्रदर्शित करने के लिए संस्थाओं स्प्राइट समूह का उपयोग किया जाएगा।
प्लेटफ़ॉर्म सरणी का उपयोग प्लेटफ़ॉर्म के साथ चौराहे की जांच के लिए किया जाएगा।

अगला ब्लॉक

 if col == "-": # ,       pf = Surface((PLATFORM_WIDTH,PLATFORM_HEIGHT)) pf.fill(Color(PLATFORM_COLOR)) screen.blit(pf,(x,y)) 

से बदलें

 if col == "-": pf = Platform(x,y) entities.add(pf) platforms.append(pf) 

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

इसके अलावा, हम पूरे स्तर की पीढ़ी कोड को लूप से हटा देते हैं।

और एक लाइन भी
Hero.draw (स्‍क्रीन) # मैपिंग
से बदलें

 entities.draw(screen) #   

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

हम खिलाडी फाइल में काम करते हैं

हम ड्रा विधि निकालते हैं, हमें अब इसकी आवश्यकता नहीं है। और एक नया टकराव विधि जोड़ें

 def collide(self, xvel, yvel, platforms): for p in platforms: if sprite.collide_rect(self, p): #       if xvel > 0: #    self.rect.right = p.rect.left #     if xvel < 0: #    self.rect.left = p.rect.right #     if yvel > 0: #    self.rect.bottom = p.rect.top #     self.onGround = True #    -  self.yvel = 0 #     if yvel < 0: #    self.rect.top = p.rect.bottom #     self.yvel = 0 #     

इस पद्धति में, नायक और प्लेटफार्मों के निर्देशांक के चौराहे के लिए एक चेक बनाया जाता है, अगर कोई एक है, तो ऊपर वर्णित कार्रवाई होती है।

खैर, और ऐसा होने के लिए, आपको इस विधि को कॉल करना होगा।
अद्यतन पद्धति के लिए तर्कों की संख्या बदलें, अब यह इस तरह दिखता है:

 update(self, left, right, up, platforms) 

और मुख्य फाइल में इसके कॉल को बदलना न भूलें।

और तर्ज

 self.rect.y += self.yvel self.rect.x += self.xvel #     xvel 

इसके साथ बदलें:

 self.rect.y += self.yvel self.collide(0, self.yvel, platforms) self.rect.x += self.xvel #     xvel self.collide(self.xvel, 0, platforms) 

यानी ऊर्ध्वाधर चौराहे के लिए नायक को लंबवत रूप से जांचा गया, क्षैतिज रूप से स्थानांतरित किया गया, क्षैतिज चौराहे के लिए फिर से जाँच की गई।

ऐसा तब होता है जब हम इसे चलाते हैं।

फू [य]! एक चलती आयत सुंदर नहीं है!

चलो हमारे मारियो बॉय को थोड़ा अलंकृत करें।

आइए प्लेटफार्मों के साथ शुरू करते हैं। ऐसा करने के लिए, blocks.py फ़ाइल में छोटे परिवर्तन करें।

इस लाइन के लिए, चित्र पर रंग भरें
self.image.fill (रंग (PLATFORM_COLOR))
से बदलें

 self.image = image.load("blocks/platform.png") 

हम एक ठोस रंग के बजाय एक तस्वीर अपलोड करते हैं। बेशक, platform.png फ़ाइल ब्लॉक फ़ोल्डर में होनी चाहिए, जिसे स्रोत निर्देशिका में स्थित होना चाहिए।

वही हुआ



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

सबसे पहले, स्थिरांक के ब्लॉक में जोड़ें।

 ANIMATION_DELAY = 0.1 #    ANIMATION_RIGHT = [('mario/r1.png'), ('mario/r2.png'), ('mario/r3.png'), ('mario/r4.png'), ('mario/r5.png')] ANIMATION_LEFT = [('mario/l1.png'), ('mario/l2.png'), ('mario/l3.png'), ('mario/l4.png'), ('mario/l5.png')] ANIMATION_JUMP_LEFT = [('mario/jl.png', 0.1)] ANIMATION_JUMP_RIGHT = [('mario/jr.png', 0.1)] ANIMATION_JUMP = [('mario/j.png', 0.1)] ANIMATION_STAY = [('mario/0.png', 0.1)] 

यहाँ, मुझे लगता है, यह समझने योग्य है, नायक के विभिन्न कार्यों का एनीमेशन।

अब निम्नलिखित को __init__ विधि में जोड़ें

 self.image.set_colorkey(Color(COLOR)) #    #    boltAnim = [] for anim in ANIMATION_RIGHT: boltAnim.append((anim, ANIMATION_DELAY)) self.boltAnimRight = pyganim.PygAnimation(boltAnim) self.boltAnimRight.play() #    boltAnim = [] for anim in ANIMATION_LEFT: boltAnim.append((anim, ANIMATION_DELAY)) self.boltAnimLeft = pyganim.PygAnimation(boltAnim) self.boltAnimLeft.play() self.boltAnimStay = pyganim.PygAnimation(ANIMATION_STAY) self.boltAnimStay.play() self.boltAnimStay.blit(self.image, (0, 0)) # -,  self.boltAnimJumpLeft= pyganim.PygAnimation(ANIMATION_JUMP_LEFT) self.boltAnimJumpLeft.play() self.boltAnimJumpRight= pyganim.PygAnimation(ANIMATION_JUMP_RIGHT) self.boltAnimJumpRight.play() self.boltAnimJump= pyganim.PygAnimation(ANIMATION_JUMP) self.boltAnimJump.play() 

यहां, प्रत्येक कार्रवाई के लिए, हम एनिमेशन का एक सेट बनाते हैं, और उन्हें चालू करते हैं (यानी, फ्रेम परिवर्तन चालू करें)।

 for anim in ANIMATION_LEFT: boltAnim.append((anim, ANIMATION_DELAY 

))
प्रत्येक फ्रेम में एक चित्र और प्रदर्शन समय होता है।

वांछित एनीमेशन दिखाने के लिए यह सही समय पर रहता है।

अद्यतन विधि में एनिमेशन का एक परिवर्तन जोड़ें ।

 if up: if self.onGround: # ,       self.yvel = -JUMP_POWER self.image.fill(Color(COLOR)) self.boltAnimJump.blit(self.image, (0, 0)) if left: self.xvel = -MOVE_SPEED #  = x- n self.image.fill(Color(COLOR)) if up: #       self.boltAnimJumpLeft.blit(self.image, (0, 0)) else: self.boltAnimLeft.blit(self.image, (0, 0)) if right: self.xvel = MOVE_SPEED #  = x + n self.image.fill(Color(COLOR)) if up: self.boltAnimJumpRight.blit(self.image, (0, 0)) else: self.boltAnimRight.blit(self.image, (0, 0)) if not(left or right): # ,     self.xvel = 0 if not up: self.image.fill(Color(COLOR)) self.boltAnimStay.blit(self.image, (0, 0)) 

देखा!

ज्यादा जगह की जरूरत है

हम एक गतिशील कैमरा बनाकर खिड़की के आकार में सीमा को पार करेंगे।

ऐसा करने के लिए, कैमरा वर्ग बनाएं

 class Camera(object): def __init__(self, camera_func, width, height): self.camera_func = camera_func self.state = Rect(0, 0, width, height) def apply(self, target): return target.rect.move(self.state.topleft) def update(self, target): self.state = self.camera_func(self.state, target.rect) 

अगला, कैमरे का प्रारंभिक कॉन्फ़िगरेशन जोड़ें।

 def camera_configure(camera, target_rect): l, t, _, _ = target_rect _, _, w, h = camera l, t = -l+WIN_WIDTH / 2, -t+WIN_HEIGHT / 2 l = min(0, l) #      l = max(-(camera.width-WIN_WIDTH), l) #      t = max(-(camera.height-WIN_HEIGHT), t) #      t = min(0, t) #      return Rect(l, t, w, h) 

आइए एक कैमरा उदाहरण बनाएं, इसे मुख्य लूप से पहले जोड़ें:

 total_level_width = len(level[0])*PLATFORM_WIDTH #     total_level_height = len(level)*PLATFORM_HEIGHT #  camera = Camera(camera_configure, total_level_width, total_level_height) 

हमने क्या किया है?

हमने एक बड़ी आयत के अंदर बनाया, जिसके आयामों की गणना निम्नानुसार की गई है:

 total_level_width = len(level[0])*PLATFORM_WIDTH #     total_level_height = len(level)*PLATFORM_HEIGHT #  

छोटी आयत, खिड़की के आकार के समान।

छोटी आयत मुख्य चरित्र ( अपडेट विधि) के सापेक्ष केंद्रित है, और सभी वस्तुओं को छोटे आयत ( लागू विधि) में खींचा जाता है, जो कैमरा आंदोलन की छाप बनाता है।

उपरोक्त के लिए, आपको ऑब्जेक्ट्स की ड्राइंग को बदलने की आवश्यकता है।

लाइन बदलें
संस्थाओं। वापस (स्क्रीन) # मानचित्रण
पर

 for e in entities: screen.blit(e.image, camera.apply(e)) 

और इससे पहले जोड़ें

 camera.update(hero) #     

अब हम स्तर बदल सकते हैं।

 level = [ "----------------------------------", "- -", "- -- -", "- -", "- -- -", "- -", "-- -", "- -", "- ---- --- -", "- -", "-- -", "- -", "- --- -", "- -", "- -", "- --- -", "- -", "- ------- ---- -", "- -", "- - -", "- -- -", "- -", "- -", "----------------------------------"] 

यहाँ, वास्तव में, परिणाम है


रिजल्ट डाउनलोड किया जा सकता है, GitHub का लिंक

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

upd pygame को यहाँ से डाउनलोड किया जा सकता है , धन्यवाद, टिप्पणी के लिए Chris_Griffin
upd1 दूसरा भाग