ეს არის შესავალი Pygame– ში მათთვის, ვინც უკვე იცნობს პითონს. ეს სტატია გასწავლით ნაბიჯებს მარტივი თამაშის შესაქმნელად, რომელშიც მოთამაშე თავს არიდებს ბურთებს.
ნაბიჯები
ნაწილი 1 8 -დან: Pygame– ის დაყენება
ნაბიჯი 1. ჩამოტვირთეთ Pygame
იპოვეთ იგი თქვენი პლატფორმისთვის
ნაბიჯი 2. გაუშვით ინსტალერი
ნაბიჯი 3. დარწმუნდით, რომ ინსტალაცია მუშაობდა
გახსენით პითონის ტერმინალი. აკრიფეთ "პიგამენტის იმპორტი". თუ თქვენ ვერ ხედავთ შეცდომებს, მაშინ Pygame წარმატებით დაინსტალირდა.
პიგამეტის იმპორტი
ნაწილი 8 8: ძირითადი ფანჯრის დაყენება
ნაბიჯი 1. გახსენით ახალი ფაილი
ნაბიჯი 2. Pygame- ის იმპორტი
Pygame არის ბიბლიოთეკა, რომელიც უზრუნველყოფს წვდომას გრაფიკულ ფუნქციებზე. თუ გსურთ მეტი ინფორმაცია იმის შესახებ, თუ როგორ მუშაობს ეს ფუნქციები, შეგიძლიათ ნახოთ ისინი Pygame ვებსაიტზე.
pygame– ის იმპორტი pygame– დან. ადგილობრივი იმპორტი *
ნაბიჯი 3. დააყენეთ ფანჯრის გარჩევადობა
თქვენ შექმნით გლობალურ ცვლადს ეკრანის გარჩევადობისთვის, რათა ის იყოს მითითებული თამაშის რამდენიმე ნაწილში. ასევე ადვილია ფაილის ზედა ნაწილში პოვნა, რათა მოგვიანებით შეიცვალოს. მოწინავე პროექტებისთვის, ამ ინფორმაციის ცალკე ფაილში განთავსება უკეთესი იდეა იქნება.
გარჩევადობა = (400, 300)
ნაბიჯი 4. განსაზღვრეთ რამდენიმე ფერი
პიგამაში არის ფერები (RBGA, რომლებიც მერყეობს 0 -დან 255 -მდე. ალფა მნიშვნელობა (A) არჩევითია, მაგრამ სხვა ფერები (წითელი, ლურჯი და მწვანე სავალდებულოა).
თეთრი = (255, 255, 255) შავი = (0, 0, 0) წითელი = (255, 0, 0)
ნაბიჯი 5. ეკრანის ინიციალიზაცია
გამოიყენეთ რეზოლუციის ცვლადი, რომელიც ადრე იყო განსაზღვრული.
ეკრანი = pygame.display.set_mode (გარჩევადობა)
ნაბიჯი 6. გააკეთეთ თამაშის მარყუჟი
გაიმეორეთ გარკვეული მოქმედებები ჩვენი თამაშის ყველა ჩარჩოში. გააკეთეთ მარყუჟი, რომელიც ყოველთვის გაიმეორებს ყველა ამ მოქმედების ციკლს.
მართალია:
ნაბიჯი 7. გააფერადეთ ეკრანი
ეკრანი. შეავსეთ (თეთრი)
ნაბიჯი 8. ეკრანის ჩვენება
თუ პროგრამას აწარმოებთ, ეკრანი გახდება თეთრი და შემდეგ პროგრამა დაიშლება. ეს იმიტომ ხდება, რომ ოპერაციული სისტემა უგზავნის მოვლენებს თამაშს და თამაში არაფერს აკეთებს მათთან. მას შემდეგ, რაც თამაში მიიღებს ძალიან ბევრ დაუოკებელ მოვლენას, ის დაიშლება.
მართალია:… pygame.display.flip ()
ნაბიჯი 9. გაუმკლავდეთ მოვლენებს
მიიღეთ ყველა მოვლენის სია, რომელიც მოხდა თითოეულ ჩარჩოში. თქვენ მხოლოდ ერთ ღონისძიებაზე ზრუნავთ - ღონისძიების დატოვება. ეს ხდება მაშინ, როდესაც მომხმარებელი ხურავს თამაშის ფანჯარას. ეს ასევე ხელს შეუშლის ჩვენი პროგრამის ჩამონგრევას ძალიან ბევრი მოვლენის გამო.
მართალია:… pygame.event.get- ში (): if event.type == QUIT: pygame.quit ()
ნაბიჯი 10. სცადეთ
აი, როგორი უნდა იყოს კოდი ახლა:
pygame– დან pygame.locals იმპორტი * გარჩევადობა = (400, 300) თეთრი = (255, 255, 255) შავი = (0, 0, 0) წითელი = (255, 0, 0) ეკრანი = pygame.display.set_mode (რეზოლუცია) ხოლო True: screen.fill (თეთრი) pygame.display.flip () pygame.event.get () ღონისძიებისთვის (): if event.type == QUIT: pygame.quit ()
ნაწილი 3 მე -8: თამაშის ობიექტის შექმნა
ნაბიჯი 1. შექმენით ახალი კლასი და კონსტრუქტორი
დააყენეთ ობიექტის ყველა თვისება. თქვენ ასევე აძლევთ ნაგულისხმევ მნიშვნელობებს ყველა თვისებისთვის.
კლასის ბურთი: def _init _ (self, xPos = გარჩევადობა [0] / 2, yPos = გარჩევადობა [1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos საკუთარი.dx = xVel self.dy = yVel self.radius = rad self.type = "ბურთი"
ნაბიჯი 2. განსაზღვრეთ როგორ დავხატოთ ობიექტი
გამოიყენეთ თვისებები, რომლებიც განისაზღვრება კონსტრუქტორში, რომ მიაპყროს ბურთი წრედ, ასევე გადასცეს ფუნქცია ზედაპირზე ობიექტის დასახატად. ზედაპირი იქნება ეკრანის ობიექტი, რომელიც ადრე შეიქმნა რეზოლუციის გამოყენებით.
def draw (self, ზედაპირზე): pygame.draw.circle (ზედაპირზე, შავი, (self.x, self.y), self.radius)
ნაბიჯი 3. შექმენით კლასის მაგალითი, ასევე უთხარით თამაშის მარყუჟს, რომ დახაზოს ბურთი ყველა მარყუჟში
ბურთი = ბურთი () მართალია:… ბურთი. ხატვა (ეკრანი)
ნაბიჯი 4. გადაადგილება ობიექტის
შექმენით ფუნქცია, რომელიც განაახლებს ობიექტის პოზიციას. დარეკეთ ამ ფუნქციის ყველა თამაშის მარყუჟში.
კლასის ბურთი:… def განახლება (თვით): self.x += self.dx self.y += self.dy
ნაბიჯი 5. შეზღუდეთ კადრების სიხშირე
ბურთი ძალიან სწრაფად იმოძრავებს, რადგან თამაშის მარყუჟი წამში ასჯერ გადის. გამოიყენეთ Pygame– ის საათი, რათა შეზღუდოთ კადრების სიხშირე 60 fps– მდე.
საათი = pygame.time. Clock () ხოლო True:… clock.tick (60)
ნაბიჯი 6. შეინახეთ ბურთი ეკრანზე
დაამატეთ ჩეკები განახლების ფუნქციაში, რომ შეცვალოთ ბურთის მიმართულება, თუ ის ეკრანის ერთ კიდეზე მოხვდება.
კლასის ბურთი:… def განახლება (თვით):… if (self.x <= 0 ან self.x> = გარჩევადობა [0]): self.dx *= -1 თუ (self.y <= 0 ან self.y > = რეზოლუცია [1]): self.dy *= -1
ნაბიჯი 7. სცადეთ
აი, როგორი უნდა იყოს კოდი ახლა:
pygame– დან pygame.locals იმპორტი * გარჩევადობა = (400, 300) თეთრი = (255, 255, 255) შავი = (0, 0, 0) წითელი = (255, 0, 0) ეკრანი = pygame.display.set_mode (რეზოლუცია) კლასის ბურთი: 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 draw (self, ზედაპირზე): pygame.draw.circle (ზედაპირზე, შავი, (self.x, self.y), self.radius) def განახლება (თვით): self.x += self.dx self.y += self.dy თუ (self.x <= 0 ან self.x> = გარჩევადობა [0]): self.dx *= -1 if (self.y <= 0 ან self.y> = გარჩევადობა [1]): self.dy *= -1 ბურთი = ბურთი () საათი = pygame.time. Clock () ხოლო True: ეკრანი. შევსება (თეთრი) ball.draw (ეკრანი) ball.update () pygame.display.flip () clock.tick (60) ღონისძიებისთვის pygame.event.get (): if event.type == QUIT: pygame.quit ()
ნაწილი 4 მე -8: თამაშის ორგანიზება
ნაბიჯი 1. გამოიყენეთ კლასები ყველაფრის ორგანიზებისთვის
თამაში უფრო გართულდება. გამოიყენეთ ობიექტზე ორიენტირებული ტექნიკა თქვენი კოდის ორგანიზებისთვის.
ნაბიჯი 2. ჩადეთ თამაშის მარყუჟი კლასში
ვინაიდან ჩვენს თამაშს ახლა აქვს მონაცემები თქვენი თამაშის ობიექტებისა და ფუნქციების ჩათვლით, აზრი აქვს თქვენი თამაშის მარყუჟის კლასად გადაქცევას.
კლასის თამაში ():
ნაბიჯი 3. დაამატეთ კონსტრუქტორი
აქ თქვენ დააინსტალირებთ თამაშის ზოგიერთ ობიექტს, შექმნით ჩვენს ეკრანს და საათს და იწყებთ Pygame– ს. Pygame უნდა იყოს ინიციალიზებული, რომ გამოიყენოს გარკვეული ფუნქციები, როგორიცაა ტექსტი ან ხმა.
კლასის თამაში (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (გარჩევადობა) self.clock = pygame.time. Clock ()
ნაბიჯი 4. მოვლენების დამუშავება ფუნქციაში
კლასის თამაში ():… def handleEvents (self): pygame.event.get ღონისძიებისთვის (): if event.type == QUIT: pygame.quit ()
ნაბიჯი 5. გახადეთ თამაშის მარყუჟი ფუნქცია
დარეკეთ ღონისძიების მართვის ფუნქცია ყოველ მარყუჟში.
კლასის თამაში ():… def run (self): while True: self.handleEvents () self.screen.fill (თეთრი) self.clock.tick (60) pygame.display.flip ()
ნაბიჯი 6. გაუმკლავდეთ თამაშის მრავალ ობიექტს
ახლა ამ კოდმა უნდა გამოიძახოს დახაზვა და განახლება ჩვენს ობიექტზე თითოეული ჩარჩო. ეს არეული იქნებოდა, თუ ბევრი ობიექტი გქონდათ. მოდით დავამატოთ ჩვენი ობიექტი მასივს და შემდეგ განვაახლოთ და დავხატოთ მასივის ყველა ობიექტი ყველა მარყუჟში. ახლა თქვენ შეგიძლიათ მარტივად დაამატოთ სხვა ობიექტი და მიანიჭოთ მას განსხვავებული საწყისი პოზიცია.
კლასის თამაში (): def _init _ (self):… self.gameObjects = self.gameObjects.append (ბურთი ()) self.gameObjects.append (ბურთი (100))… def გაშვება (self): ხოლო მართალია: 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.flip ()
ნაბიჯი 7. სცადეთ
აი, როგორი უნდა იყოს კოდი ახლა:
pygame– დან pygame.locals იმპორტი * გარჩევადობა = (400, 300) თეთრი = (255, 255, 255) შავი = (0, 0, 0) წითელი = (255, 0, 0) ეკრანი = pygame.display.set_mode (რეზოლუცია) კლასის ბურთი: 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 draw (self, ზედაპირზე): pygame.draw.circle (ზედაპირზე, შავი, (self.x, self.y), self.radius) def განახლება (თვით): self.x += self.dx self.y += self.dy თუ (self.x <= 0 ან self.x> = გარჩევადობა [0]): self.dx *= -1 if (self.y <= 0 ან self.y> = გარჩევადობა [1]): self.dy *= -1 კლასის თამაში (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (გარჩევადობა) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (ბურთი ()) self.gameObjects.append (ბურთი (100)) def handleEvents (self): pygame.event.get () ღონისძიებისთვის: if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvent s () 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 გადატრიალება () თამაში (). გაშვება ()
ნაწილი 5 8 -დან: მოთამაშის ობიექტის დამატება
ნაბიჯი 1. გააკეთეთ მოთამაშეთა კლასი და კონსტრუქტორი
თქვენ აპირებთ კიდევ ერთი წრის შექმნას, რომელსაც თაგვი აკონტროლებს. კონსტრუქტორში მნიშვნელობების ინიციალიზაცია. რადიუსი არის ერთადერთი მნიშვნელოვანი მნიშვნელობა.
კლასის მოთამაშე: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
ნაბიჯი 2. განსაზღვრეთ როგორ დავხატოთ მოთამაშის ობიექტი
ეს იქნება ზუსტად ისე, როგორც თქვენ დახატეთ თამაშის სხვა ობიექტები.
კლასის მოთამაშე:… def draw (self, ზედაპირზე): pygame.draw.circle (ზედაპირზე, წითელი, (self.x, self.y), self.radius)
ნაბიჯი 3. დაამატეთ მაუსის კონტროლი პლეერის ობიექტისთვის
ყველა ჩარჩოში შეამოწმეთ თაგვის ადგილმდებარეობა და დააყენეთ მოთამაშეთა ობიექტების მდებარეობა იმ წერტილში.
კლასის მოთამაშე:… def განახლება (თვით): cord = pygame.mouse.get_pos () self.x = კაბელი [0] self.y = კაბელი [1]
ნაბიჯი 4. დაამატეთ მოთამაშის ობიექტი gameObjects- ს
შექმენით ახალი მოთამაშის მაგალითი და დაამატეთ იგი სიაში.
კლასის თამაში (): def _init _ (self):… self.gameObjects.append (მოთამაშე ())
ნაბიჯი 5. სცადეთ
აი, როგორი უნდა იყოს კოდი ახლა:
pygame– დან pygame.locals იმპორტი * გარჩევადობა = (400, 300) თეთრი = (255, 255, 255) შავი = (0, 0, 0) წითელი = (255, 0, 0) ეკრანი = pygame.display.set_mode (რეზოლუცია) კლასის ბურთი: 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 draw (self, ზედაპირზე): pygame.draw.circle (ზედაპირზე, შავი, (self.x, self.y), self.radius) def განახლება (თვით): self.x += self.dx self.y += self.dy თუ (self.x <= 0 ან self.x> = გარჩევადობა [0]): self.dx *= -1 if (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 draw (self, ზედაპირზე): pygame.draw.circle (ზედაპირზე, წითელი, (self.x, self.y), self.radius) def განახლება (საკუთარი): cord = pygame.mouse.get_pos () self.x = ტვინი [0] self.y = ტვინი [1] კლასის თამაში (): def _init _ (self): pygame.init () self.screen = pygame. ჩვენება. დაყენება რეჟიმი (გარჩევადობა) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (მოთამაშე ()) self.gameObjects.append (ბურთი ()) self.gameObjects.append (ბურთი (100)) def handleEvents (self): pygame.event.get () ღონისძიებისთვის: if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update () self.screen.fill (თეთრი) for gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () თამაში () გაშვება ()
ნაწილი 6 მე -8: ობიექტების ურთიერთქმედება მოთამაშესთან
ნაბიჯი 1. შეცვალეთ განახლების ფუნქციები
იმისათვის, რომ საგნები ურთიერთქმედებდნენ, მათ ერთმანეთთან წვდომა დასჭირდებათ. მოდით დავამატოთ კიდევ ერთი პარამეტრი განახლებას, რათა გაიაროთ gameObjects სიაში. თქვენ უნდა დაამატოთ ის როგორც მოთამაშის ობიექტს, ასევე ბურთის ობიექტებს. თუ თქვენ გაქვთ ბევრი სათამაშო ობიექტი, მემკვიდრეობა დაგეხმარებათ ყველა თქვენი მეთოდის ხელმოწერის შენარჩუნებაში.
კლასის ბურთი:… def განახლება (საკუთარი თავი, თამაშის ობიექტები):… კლასის მოთამაშე:… def განახლება (თვით, თამაშის ობიექტები):
ნაბიჯი 2. შეამოწმეთ მოთამაშესა და ბურთებს შორის შეჯახება
გაიარეთ თამაშის ყველა ობიექტი და შეამოწმეთ არის თუ არა ობიექტის ტიპი ბურთი. შემდეგ გამოიყენეთ ორი ობიექტის რადიუსი და მანძილის ფორმულა, რათა შეამოწმოთ შეჯახებულია თუ არა ისინი. წრეებზე მართლაც ადვილია შეჯახების შემოწმება. ეს არის ყველაზე დიდი მიზეზი იმისა, რომ თქვენ არ გამოგიყენებიათ რაიმე სხვა ფორმა ამ თამაშისთვის.
კლასის მოთამაშე:… def განახლება (თვით, gameObjects):… for gameObj in gameObjects: if gameObj.type == "ბურთი": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 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– დან pygame.locals იმპორტი * გარჩევადობა = (400, 300) თეთრი = (255, 255, 255) შავი = (0, 0, 0) წითელი = (255, 0, 0) ეკრანი = pygame.display.set_mode (რეზოლუცია) კლასის ბურთი: 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 draw (self, ზედაპირზე): pygame.draw.circle (ზედაპირზე, შავი, (self.x, self.y), self.radius) def განახლება (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 ან self.x> = გარჩევადობა [0]): self.dx *= -1 if (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 draw (self, ზედაპირზე): pygame.draw.circle (ზედაპირზე, წითელი, (self.x, self.y), self.radius) def განახლება (თვით, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] for gameObj in gameObjects: if gameObj.type == "ბურთი": 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 (მოთამაშე ()) self.gameObjects.append (ბურთი ()) self.gameObjects.append (ბურთი (100)) def handleEvents (თვითმმართველობის): ღონისძიებისთვის pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (white) for gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () თამაში (). გაშვება ()
ნაწილი 7 მე -8: თამაშის კონტროლერის დამატება ობიექტების შესაქმნელად
ნაბიჯი 1. შექმენით თამაშის კონტროლერის კლასი
თამაშის კონტროლერები პასუხისმგებელნი არიან თამაშის "გაშვებაზე". ის განსხვავდება ჩვენი თამაშის კლასისგან, რომელიც პასუხისმგებელია ჩვენი ყველა ობიექტის დახაზვასა და განახლებაზე. კონტროლერი პერიოდულად დაამატებს კიდევ ერთ ბურთს ეკრანზე, რათა თამაში გაართულოს. დაამატეთ კონსტრუქტორი და დაიწყეთ რამდენიმე ძირითადი მნიშვნელობა. ინტერვალი იქნება სხვა ბურთის დამატებამდე.
კლასის GameController: def _init _ (self, interval = 5): self.inter = ინტერვალი self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "თამაშის კონტროლერი"
ნაბიჯი 2. დაამატეთ განახლების ფუნქცია
ეს შეამოწმებს რამდენი დრო გავიდა მას შემდეგ, რაც ბურთი დაემატა ან თამაშის დაწყებიდან. თუ დრო ინტერვალზე მეტია თქვენ გადააყენებთ დროს და დაამატებთ ბურთს.
კლასის GameController:… def განახლება (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (ბურთი ())
ნაბიჯი 3. მიეცით ბურთებს შემთხვევითი სიჩქარე
თქვენ უნდა გამოიყენოთ შემთხვევითი რიცხვები, რომ თამაში ყოველ ჯერზე განსხვავებული გახადოთ. თუმცა, ბურთების სიჩქარე არის მცურავი წერტილის რიცხვი მთლიანი რიცხვის ნაცვლად.
კლასის GameController:… def განახლება (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (ბურთი (xVel = შემთხვევითი ()*2, yVel = შემთხვევითი ()*2))
ნაბიჯი 4. შეასწორეთ ხატვის ფუნქცია
გათამაშების ფუნქცია არ მიიღებს მცურავებს. მოდით გადავიყვანოთ ბურთის პოზიცია მთელ რიცხვზე სანამ ბურთები დახატული იქნება.
კლასის ბურთი:… def draw (self, ზედაპირზე): pygame.draw.circle (ზედაპირზე, შავი, (int (self.x), int (self.y)), self.radius)
ნაბიჯი 5. განსაზღვრეთ გათამაშების მეთოდი თამაშის კონტროლერისთვის
ვინაიდან ეს არის თამაშის ობიექტი, მთავარი მარყუჟი შეეცდება მის დახატვას. თქვენ უნდა განსაზღვროთ გათამაშების ფუნქცია, რომელიც არაფერს აკეთებს ისე, რომ თამაში არ ჩავარდეს.
კლასის GameController:… def draw (self, screen): pass
ნაბიჯი 6. დაამატეთ თამაშის კონტროლერი gameObjects და ამოიღეთ 2 ბურთი
თამაშმა უნდა აწარმოოს ბურთი ყოველ ხუთ წამში.
კლასის თამაში (): def _init _ (self):… self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (მოთამაშე ())
ნაბიჯი 7. სცადეთ
აი, როგორი უნდა იყოს კოდი ახლა:
pygame იმპორტირებული შემთხვევითი იმპორტიდან pygame.locals იმპორტი * გარჩევადობა = (400, 300) თეთრი = (255, 255, 255) შავი = (0, 0, 0) წითელი = (255, 0, 0) ეკრანი = პიგამა. display.set_mode (გარჩევადობა) კლასი ბურთი: 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 draw (self, ზედაპირზე): pygame.draw.circle (ზედაპირზე, შავი, (int (თვითმმართველობის x), int (self.y)), self.radius) def განახლება (self, gameObjects): self.x += self.dx self.y += self.dy თუ (self.x <= 0 ან თვით. x> = გარჩევადობა [0]): self.dx *= -1 if (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 draw (self, ზედაპირზე): pygame.draw.circle (ზედაპირზე, წითელი, (self.x, self.y), self.radius) def განახლება (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] for gameObj თამაშში ობიექტები: if gameObj.type == "ბურთი": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius)* * 2: pygame.quit () კლასის GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "თამაშის კონტროლერი "def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (ბურთი (xVel = შემთხვევითი ()*2, yVel = შემთხვევითი ()*2)) def გათამაშება (საკუთარი თავი, ეკრანი): კლასის გავლა თამაში (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (გარჩევადობა) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (მოთამაშე ()) def handleEvents (საკუთარი): pygame.event– ში მოვლენისთვის.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update (self.gameObjects) self.screen.შეავსე (თეთრი) თამაშისათვის Obj in self.gameO bjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () თამაში () გაშვება ()
მე -8 ნაწილი 8 -დან: ქულის დამატება და თამაში დასრულდა
ნაბიჯი 1. დაამატეთ ანგარიში თამაშის კონტროლერის კლასს
შექმენით შრიფტის ობიექტი და ქულის ცვლადი. თქვენ დახატავთ შრიფტს ყველა ჩარჩოში, რომ ნახოთ ანგარიში და გაზარდოთ ქულა განახლების ყოველი ჩარჩო.
კლასის GameController: def _init _ (self, interval = 5):… self.score = 0 self.scoreText = pygame.font. Font (არცერთი, 12) def განახლება (self, gameObjects):… self.score += 1 def გათამაშება (საკუთარი, ეკრანი): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5))
ნაბიჯი 2. შეცვალეთ როგორ დასრულდება თამაში
მოდით, თავი დავანებოთ დატოვებას, როდესაც მოთამაშე აღმოაჩენს შეჯახებას. ამის ნაცვლად, თქვენ დააყენებთ ცვლადს მოთამაშეს, რომლის შემოწმებაც თამაშს შეუძლია. როდესაც gameOver დაყენებულია, შეწყვიტეთ ობიექტების განახლება. ეს გაყინავს ყველაფერს თავის ადგილზე ისე, რომ მოთამაშემ ნახოს რა მოხდა და შეამოწმოს თავისი ანგარიში. გაითვალისწინეთ, რომ ობიექტები ჯერ კიდევ ხატავს, უბრალოდ არ განახლდება.
კლასის მოთამაშე: def _init _ (self, rad = 20):… self.gameOver = ყალბი def განახლება (self, gameObjects):… for gameObj in 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 = ყალბი def გაშვება (საკუთარი): ხოლო True: self.handleEvents () თუ არა self.gameOver: for gameObj in self.gameObjects: gameObj.update (self.gameObjects) თუ gameObj.type == "მოთამაშე": self.gameOver = gameObj.gameOver
ნაბიჯი 3. სცადეთ
აი, როგორი უნდა იყოს მზა კოდი ახლა:
პიგამას შემოტანა პიგამიდან შემთხვევითი იმპორტიდან. ლოკალური იმპორტი * გარჩევადობა = (400, 300) თეთრი = (255, 255, 255) შავი = (0, 0, 0) წითელი = (255, 0, 0) ეკრანი = პიგამა. display.set_mode (გარჩევადობა) კლასი ბურთი: 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 draw (self, ზედაპირზე): pygame.draw.circle (ზედაპირზე, შავი, (int (თვითმმართველობის x), int (self.y)), self.radius) def განახლება (self, gameObjects): self.x += self.dx self.y += self.dy თუ (self.x <= 0 ან თვით. x> = რეზოლუცია [0]): self.dx *= -1 if (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 = "მოთამაშე" self.gameOver = ყალბი def გათამაშება (საკუთარი თავი, ზედაპირი): pygame.draw.circle (ზედაპირი, წითელი, (self.x, self.y), self.radius) def განახლება (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] for gameObj in gameObjects: if gameObj.type == "ბურთი": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = ნამდვილი კლასის GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2*1000) self. type = "თამაშის კონტროლერი" self.score = 0 self.scoreText = pygame.font. Font (არცერთი, 12) def განახლება (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter*1000) თამაშიObjects.append (ბურთი (xVel = შემთხვევითი ()*2, yVel = შემთხვევითი ()*2)) self.score + = 1 def გათამაშება (საკუთარი თავი, ეკრანი): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5)) კლასის თამაში (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (გარჩევადობა) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (მოთამაშე ()) self.gameOver = ყალბი def handleEvents (self): pygame.event.get.get () მოვლენისთვის: თუ ev ent.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () თუ არა self.gameOver: for gameObj in self.gameObjects: gameObj.update (self.gameObjects) თუ gameObj. ტიპი == "მოთამაშე": self.gameOver = gameObj.gameOver self.screen.fill (თეთრი) for gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () თამაში (). გაუშვით ()
