हम पायथन में एक प्लेटफ़ॉर्मर लिख रहे हैं। भाग 2. सबपार्ट 1, स्तर संपादक बनाने की तैयारी

नमस्कार दोस्तों!

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

अपग्रेड हीरो

हमारे हीरो में तेजी लाने का अवसर जोड़ें। ऐसा करने के लिए, अपडेट विधि कोड को थोड़ा संशोधित करें।

शुरुआत के लिए, स्थिरांक जोड़ें

MOVE_EXTRA_SPEED = 2.5 #  JUMP_EXTRA_POWER = 1 #    ANIMATION_SUPER_SPEED_DELAY = 0.05 #      

अगला, गति में बाएँ - दाएँ गति एनिमेशन जोड़ें। हम एक ही चित्र सम्मिलित करेंगे, लेकिन एक अलग फ्रेम दर के साथ

 #    boltAnim = [] boltAnimSuperSpeed = [] for anim in ANIMATION_RIGHT: boltAnim.append((anim, ANIMATION_DELAY)) boltAnimSuperSpeed.append((anim, ANIMATION_SUPER_SPEED_DELAY)) self.boltAnimRight = pyganim.PygAnimation(boltAnim) self.boltAnimRight.play() self.boltAnimRightSuperSpeed = pyganim.PygAnimation(boltAnimSuperSpeed) self.boltAnimRightSuperSpeed.play() #    boltAnim = [] boltAnimSuperSpeed = [] for anim in ANIMATION_LEFT: boltAnim.append((anim, ANIMATION_DELAY)) boltAnimSuperSpeed.append((anim, ANIMATION_SUPER_SPEED_DELAY)) self.boltAnimLeft = pyganim.PygAnimation(boltAnim) self.boltAnimLeft.play() self.boltAnimLeftSuperSpeed = pyganim.PygAnimation(boltAnimSuperSpeed) self.boltAnimLeftSuperSpeed.play() 

स्वयं को तेज करते समय एनिमेशन के 2 सेट जोड़े गए। AbnimRightSuperSpeed , self.boltAnimLeftSuperSpeed , हम उन्हें थोड़ा कम प्रदर्शित करेंगे

चलिए अब हम अपडेट विधि के लिए नीचे आते हैं।

इनपुट पैरामीटर जोड़ें

 def update(self, left, right, up, running, platforms): 

त्वरण व्यवहार को जोड़कर चरित्र की चाल की प्रक्रिया को बदलें।

 if up: if self.onGround: # ,       self.yvel = -JUMP_POWER if running and (left or right): #       self.yvel -= JUMP_EXTRA_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 running: #   self.xvel-=MOVE_EXTRA_SPEED #    if not up: #     self.boltAnimLeftSuperSpeed.blit(self.image, (0, 0)) #     else: #    if not up: #    self.boltAnimLeft.blit(self.image, (0, 0)) #    if up: #    self.boltAnimJumpLeft.blit(self.image, (0, 0)) #    if right: self.xvel = MOVE_SPEED #  = x + n self.image.fill(Color(COLOR)) if running: self.xvel+=MOVE_EXTRA_SPEED if not up: self.boltAnimRightSuperSpeed.blit(self.image, (0, 0)) else: if not up: self.boltAnimRight.blit(self.image, (0, 0)) if up: self.boltAnimJumpRight.blit(self.image, (0, 0)) 

और मुख्य फ़ाइल में, बाईं पारी को दबाने की घटना का प्रसंस्करण जोड़ें।

 running = False *** if e.type == KEYDOWN and e.key == K_LSHIFT: running = True *** if e.type == KEYUP and e.key == K_LSHIFT: running = False 

सभी प्रमुख कोड यहाँ

और Hero.update () पद्धति को कॉल करते समय तर्क जोड़ना न भूलें

 hero.update(left, right, up, running, platforms) 

हम परिणामों को देखते हैं (मैंने क्रूर मारियो के लिए पृष्ठभूमि का रंग काला , क्रूर रंग में बदल दिया)
कोई त्वरण नहीं

त्वरण कूदो

जानलेवा स्पाइक्स

असली नायक एक वास्तविक खतरा है। चलो एक नए प्रकार के ब्लॉक बनाते हैं, जिसके संपर्क में तत्काल मृत्यु होगी।

प्लेटफ़ॉर्म से विरासत में मिली एक क्लास बनाएं।

 class BlockDie(Platform): def __init__(self, x, y): Platform.__init__(self, x, y) self.image = image.load("%s/blocks/dieBlock.png" % ICON_DIR) 

इसके बाद, नायक के व्यवहार को उसके संपर्क में जोड़ें। ऐसा करने के लिए, वर्ण वर्ग में 2 विधियाँ जोड़ें। पहला तरीका मृत्यु व्यवहार है, दूसरा निर्दिष्ट निर्देशांक के साथ बढ़ रहा है (जो नीचे एक बार फिर काम में आएगा)

 def die(self): time.wait(500) self.teleporting(self.startX, self.startY) #     def teleporting(self, goX, goY): self.rect.x = goX self.rect.y = goY 

यानी जब हम मर जाते हैं, खेल थोड़ी देर के लिए रुक जाता है, तो हम स्तर की शुरुआत में चले जाते हैं और आगे खेलते हैं।

खैर, हम चौराहे पर व्यवहार का वर्णन टकराव () विधि में मृत्यु ब्लॉक के साथ करते हैं

 *** if isinstance(p, blocks.BlockDie): #    - blocks.BlockDie self.die()#  *** 

अब, मुख्य वर्ग में हम स्तर बदलेंगे

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

और मृत्यु ब्लॉक के निर्माण को जोड़ें, अगर स्तर में "*" प्रतीक है

 if col == "*": bd = BlockDie(x,y) entities.add(bd) platforms.append(bd) 

परिणाम:

पोर्टल

बिना टेलीपोर्ट के आधुनिक प्लंबर क्या करता है? तो आइए हम अपने नायक को एक काली भेड़ न बनाएं।

एक नया ब्लॉक प्रकार बनाएँ। हम फ़ाइल को ब्लॉकसेपी में काम करते हैं

पहले स्थिरांक जोड़ें

 ANIMATION_BLOCKTELEPORT = [ ('%s/blocks/portal2.png' % ICON_DIR), ('%s/blocks/portal1.png' % ICON_DIR)] 

फिर एक नया वर्ग बनाएं।

 class BlockTeleport(Platform): def __init__(self, x, y, goX,goY): Platform.__init__(self, x, y) self.goX = goX #    self.goY = goY #    boltAnim = [] for anim in ANIMATION_BLOCKTELEPORT: boltAnim.append((anim, 0.3)) self.boltAnim = pyganim.PygAnimation(boltAnim) self.boltAnim.play() def update(self): self.image.fill(Color(PLATFORM_COLOR)) self.boltAnim.blit(self.image, (0, 0)) 

यहां कुछ नया नहीं है। बनाते समय, न केवल पोर्टल के स्थान के निर्देशांक सेट किए जाते हैं, बल्कि नायक के आंदोलन के निर्देशांक भी जब टेलीफ़ोन में हिट होते हैं।

अगला, पोर्टल के संपर्क में हमारे नायक व्यवहार में जोड़ें

 *** elif isinstance(p, blocks.BlockTeleport): self.teleporting(p.goX, p.goY) *** 

और मैप में एक पोर्टल जोड़ें। केवल अब हम निर्देशांक का मैन्युअल रूप से वर्णन करेंगे। जब हम स्तरीय संपादक बनाते हैं - तो यह आसान हो जाएगा।
एक और स्प्राइट समूह जोड़ें जिसमें एनिमेटेड ब्लॉक होंगे

 animatedEntities = pygame.sprite.Group() #   ,    

और एक teleporter बनाएँ।

 tp = BlockTeleport(128,512,800,64) entities.add(tp) platforms.append(tp) animatedEntities.add(tp) 

अंत में, सभी एनिमेटेड स्प्राइट्स पर अपडेट () विधि में कॉल जोड़ें

 animatedEntities.update() #   

कुछ इस तरह

राक्षसों

डरावना, चलती, घातक रोशनी।

राक्षसों और घातक ब्लॉकों के बीच अंतर यह है कि राक्षस स्थानांतरित कर सकते हैं।

चलिए शुरू करते हैं।

हम एक नई फ़ाइल में काम करेंगे ताकि भ्रमित न हों। चलिए इसे बहुत ही मूल रूप से कहते हैं - Monster.py

एक नया मॉन्स्टर वर्ग बनाएँ। इसमें ऐसा कुछ भी नहीं है जो हमने पहले इस्तेमाल नहीं किया हो।
संपूर्ण फ़ाइल की सामग्री

 #!/usr/bin/env python # -*- coding: utf-8 -*- from pygame import * import pyganim import os MONSTER_WIDTH = 32 MONSTER_HEIGHT = 32 MONSTER_COLOR = "#2110FF" ICON_DIR = os.path.dirname(__file__) #       ANIMATION_MONSTERHORYSONTAL = [('%s/monsters/fire1.png' % ICON_DIR), ('%s/monsters/fire2.png' % ICON_DIR )] class Monster(sprite.Sprite): def __init__(self, x, y, left, up, maxLengthLeft,maxLengthUp): sprite.Sprite.__init__(self) self.image = Surface((MONSTER_WIDTH, MONSTER_HEIGHT)) self.image.fill(Color(MONSTER_COLOR)) self.rect = Rect(x, y, MONSTER_WIDTH, MONSTER_HEIGHT) self.image.set_colorkey(Color(MONSTER_COLOR)) self.startX = x #   self.startY = y self.maxLengthLeft = maxLengthLeft #  ,       self.maxLengthUp= maxLengthUp #  ,      ,  self.xvel = left # c   , 0 -    self.yvel = up #    , 0 -   boltAnim = [] for anim in ANIMATION_MONSTERHORYSONTAL: boltAnim.append((anim, 0.3)) self.boltAnim = pyganim.PygAnimation(boltAnim) self.boltAnim.play() def update(self, platforms): #    self.image.fill(Color(MONSTER_COLOR)) self.boltAnim.blit(self.image, (0, 0)) self.rect.y += self.yvel self.rect.x += self.xvel self.collide(platforms) if (abs(self.startX - self.rect.x) > self.maxLengthLeft): self.xvel =-self.xvel #    ,      if (abs(self.startY - self.rect.y) > self.maxLengthUp): self.yvel = -self.yvel #    ,     ,  def collide(self, platforms): for p in platforms: if sprite.collide_rect(self, p) and self != p: #   -  -  self.xvel = - self.xvel #      self.yvel = - self.yvel 

एक राक्षस का निर्माण करते समय, आपको 6 तर्क निर्दिष्ट करने की आवश्यकता होती है: x , y - निर्देशांक, बाईं - क्षैतिज गति, ऊपर - ऊर्ध्वाधर गति, अधिकतम गति। अधिकतम दूरी जिस तरह से राक्षस जा सकता है, अधिकतम गति 1 - पिछले एक के समान, लेकिन लंबवत।

अब आग के संपर्क से नायक को मौत जोड़ें।

तार बदलें

 if isinstance(p, blocks.BlockDie): #    - blocks.BlockDie self.die()#  

पर

  if isinstance(p, blocks.BlockDie) or isinstance(p, monsters.Monster): #   - blocks.BlockDie  Monster self.die()#  

और राक्षसों के फ़ाइल से आयात जोड़ने के लिए मत भूलना

और, ज़ाहिर है, एक राक्षस की रचना को मुख्य फ़ाइल में जोड़ें।

चलो स्प्राइट का एक और समूह बनाते हैं जिसमें हम अपने राक्षसों को जगह देंगे।

 monsters = pygame.sprite.Group() #    

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

राक्षस को ही पैदा करो।

 mn = Monster(190,200,2,3,150,15) entities.add(mn) platforms.append(mn) monsters.add(mn) 

और उसे हिलाओ

 monsters.update(platforms) #    

हम परिणाम को देखते हैं।

राजकुमारी

किसी भी प्लंबर के लिए सम्मान की बात राजकुमारी को बचाना है।

राजकुमारी वर्ग हमारे लिए कुछ भी दिलचस्प नहीं रखता है, इसलिए मैं इसका कोड नहीं दिखाऊंगा। कौन रुचि रखता है - ब्लॉकसीपी फ़ाइल में देखें

हम विजेता गुण को अपने चरित्र में जोड़ देंगे, जिसके द्वारा हम न्याय करेंगे कि यह स्तर पूरा होने का समय है।

 self.winner = False 

और टकराने () विधि में परिवर्तन करें

 elif isinstance(p, blocks.Princess): #    self.winner = True # !!! 

और फिर, राजकुमारी निर्माण कोड लिखें

 if col == "P": pr = Princess(x,y) entities.add(pr) platforms.append(pr) animatedEntities.add(pr) 

"पी" प्रतीक को स्तर में सम्मिलित करने के लिए याद रखें।

नज़र

स्तर

अंत में हम पार्सिंग स्तर पर पहुंच गए। हम उन्हें स्तर निर्देशिका में रखेंगे। मैं 1.txt फ़ाइल से एक स्तर का एक उदाहरण देता हूं

 [ ----------------------------------| - * -| - * *P -| ---- *--** --| - -- -| - -| - -| - -| -- ---- | - -| -- -| - ** -| - --- -| - -| - -| - --- -| - -| - -------- * ---- -| - -| - - -| - ** -- -| - * -| - ** -| --------------- *** -- -| - -| - -| ----------------------------------| ] player 55 44 portal 128 512 900 35 portal 170 512 700 64 monster 190 250 2 1 150 10 monster 190 400 2 3 150 150 monster 150 200 1 2 150 100 / 

हम यहां क्या देखते हैं? इसमें से कुछ भी जिसे इस पद पर नहीं माना जाएगा (पहले भाग सहित)। सबसे पहले, हम "[", "-", "*", "]", "|"
जहां "[" - पार्सर को स्तर की शुरुआत दिखाता है
"]" - क्रमशः, स्तर का अंत
"|" - लाइन का अंत
"-" - नियमित मंच
"*" - स्टडेड प्लेटफॉर्म

फिर, लाइन "खिलाड़ी 55 44" में हम अपने नायक के प्रारंभिक निर्देशांक को इंगित करते हैं
"पोर्टल 128 512 900 35" - पहले दो नंबर - पोर्टल के निर्देशांक, दूसरे - आंदोलन के निर्देशांक
"मॉन्स्टर 150 200 1 2 150 100" - पहले दो नंबर, इसी तरह, राक्षस के निर्देशांक, फिर, दूसरे दो - गति क्षैतिज और ऊर्ध्वाधर, और अंतिम - एक दिशा में अधिकतम दूरी क्षैतिज और लंबवत।
जैसा कि आप पहले ही देख चुके हैं, जितने चाहें उतने पोर्टल और राक्षस हो सकते हैं।
चरित्र "/" फ़ाइल के अंत को इंगित करता है। इसके बाद के सभी डेटा को पढ़ा नहीं जाएगा।

अब, तोता ही लिखते हैं।
हम मुख्य फ़ाइल में काम करते हैं।

शुरू करने के लिए, हम मुख्य कार्यक्रम से मुख्य भाग () फ़ंक्शन से सभी सरणियों और समूहों को स्थानांतरित करते हैं

 *** level = [] entities = pygame.sprite.Group() #   animatedEntities = pygame.sprite.Group() #   ,    monsters = pygame.sprite.Group() #    platforms = [] # ,        if __name__ == "__main__": main() 

फिर, स्तर को हटा दें, चर खाली होना चाहिए। इसके अलावा, राक्षसों और पोर्टलों के निर्माण को हटा दें।

और एक नया फ़ंक्शन जोड़ें

 def loadLevel(): global playerX, playerY #   ,    levelFile = open('%s/levels/1.txt' % FILE_DIR) line = " " commands = [] while line[0] != "/": #       line = levelFile.readline() #  if line[0] == "[": #      while line[0] != "]": # ,       line = levelFile.readline() #    if line[0] != "]": #       endLine = line.find("|") #      level.append(line[0: endLine]) #          "|" if line[0] != "": #     commands = line.split() #      if len(commands) > 1: #    > 1,     if commands[0] == "player": #    - player playerX= int(commands[1]) #     playerY = int(commands[2]) if commands[0] == "portal": #    portal,    tp = BlockTeleport(int(commands[1]),int(commands[2]),int(commands[3]),int(commands[4])) entities.add(tp) platforms.append(tp) animatedEntities.add(tp) if commands[0] == "monster": #    monster,    mn = Monster(int(commands[1]),int(commands[2]),int(commands[3]),int(commands[4]),int(commands[5]),int(commands[6])) entities.add(mn) platforms.append(mn) monsters.add(mn) 

इस फ़ंक्शन को कॉल करने के लिए मत भूलना और चर startX निर्दिष्ट करें और हमारे हीरो के लिए शुरुआती निर्देशांक के रूप में startY ।

 def main(): loadLevel() *** hero = Player(playerX,playerY) #    (x,y)  *** 

रिजल्ट डाउनलोड करें ।

अब स्तर फ़ाइल को हाथ से संपादित करना बहुत दिलचस्प नहीं है, इसलिए, अगले भाग में हम स्तर संपादक को ही लिखेंगे।
PS ऊपर बनाया गया स्तर काफी निष्क्रिय है, इसके लिए जाएं।