Ito ay isang pagpapakilala sa Pygame para sa mga taong nakakaalam ng Python. Ituturo sa iyo ng artikulong ito ang mga hakbang sa pagbuo ng isang simpleng laro na naiwasan ng manlalaro ang mga bouncing ball.
Mga hakbang
Bahagi 1 ng 8: Pag-install ng Pygame
Hakbang 1. I-download ang Pygame
Hanapin ito para sa iyong platform mula sa
Hakbang 2. Patakbuhin ang installer
Hakbang 3. Patunayan na ang pag-install ay gumagana
Magbukas ng isang terminal ng Python. I-type ang "import pygame." Kung wala kang nakitang anumang mga error kung gayon matagumpay na na-install ang Pygame.
i-import ang pygame
Bahagi 2 ng 8: Pag-set up ng Isang Pangunahing Window
Hakbang 1. Magbukas ng isang bagong file
Hakbang 2. I-import ang Pygame
Ang Pygame ay isang silid-aklatan na nagbibigay ng pag-access sa mga pag-andar ng graphics. Kung nais mo ng karagdagang impormasyon sa kung paano gumagana ang mga pagpapaandar na ito, maaari mong tingnan ang mga ito sa website ng Pygame.
i-import ang pygame mula sa pygame.locals import *
Hakbang 3. Itakda ang resolusyon ng window
Gagawa ka ng isang pandaigdigang variable para sa resolusyon ng screen upang ma-refer sa maraming bahagi ng laro. Madali din itong hanapin sa tuktok ng file upang mabago ito sa paglaon. Para sa mga advanced na proyekto, ang paglalagay ng impormasyong ito sa isang hiwalay na file ay magiging isang mas mahusay na ideya.
resolusyon = (400, 300)
Hakbang 4. Tukuyin ang ilang mga kulay
Ang mga kulay sa pygame ay (RBGA na saklaw sa mga halagang nasa pagitan ng 0 at 255. Ang alpha na halaga (A) ay opsyonal ngunit ang iba pang mga kulay (pula, asul, at berde ay sapilitan).
puti = (255, 255, 255) itim = (0, 0, 0) pula = (255, 0, 0)
Hakbang 5. Ipasimula ang screen
Gamitin ang variable ng resolusyon na tinukoy nang mas maaga.
screen = pygame.display.set_mode (resolusyon)
Hakbang 6. Gumawa ng isang loop ng laro
Ulitin ang ilang mga pagkilos sa bawat frame ng aming laro. Gumawa ng isang loop na palaging uulitin sa pag-ikot sa lahat ng mga pagkilos na ito.
habang Totoo:
Hakbang 7. Kulayan ang screen
screen.fill (puti)
Hakbang 8. Ipakita ang screen
Kung patakbuhin mo ang programa, ang screen ay magpaputi at pagkatapos ay mag-crash ang programa. Ito ay dahil ang operating system ay nagpapadala ng mga kaganapan sa laro at ang laro ay walang ginagawa sa kanila. Kapag ang laro ay nakakatanggap ng napakaraming mga hindi hinawakang kaganapan, ito ay mag-crash.
habang Totoo:… pygame.display.flip ()
Hakbang 9. Pangasiwaan ang mga kaganapan
Kumuha ng isang listahan ng lahat ng mga kaganapan na naganap sa bawat frame. Mag-aalala ka lang sa isang kaganapan, ang umalis na kaganapan. Nangyayari ito kapag isinara ng gumagamit ang window ng laro. Pipigilan din nito ang aming programa mula sa pag-crash dahil sa masyadong maraming mga kaganapan.
habang Totoo: … para sa kaganapan sa pygame.event.get (): kung event.type == QUIT: pygame.quit ()
Hakbang 10. Subukan ito
Narito kung ano ang dapat magmukhang code ngayon:
i-import ang pygame mula sa pygame.locals import * resolusyon = (400, 300) puti = (255, 255, 255) itim = (0, 0, 0) pula = (255, 0, 0) screen = pygame.display.set_mode (resolusyon) habang Tama: screen.fill (puti) pygame.display.flip () para sa kaganapan sa pygame.event.get (): kung event.type == QUIT: pygame.quit ()
Bahagi 3 ng 8: Paggawa ng isang Bagay sa Laro
Hakbang 1. Gumawa ng isang bagong klase at tagapagbuo
Itakda ang lahat ng mga pag-aari ng bagay. Nagbibigay ka rin ng mga default na halaga para sa lahat ng mga pag-aari.
class Ball: def _init _ (self, xPos = resolusyon [0] / 2, yPos = resolusyon [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"
Hakbang 2. Tukuyin kung paano iguhit ang bagay
Gumamit ng mga katangiang tinukoy sa tagapagbuo upang iguhit ang bola bilang isang bilog pati na rin upang ipasa ang isang ibabaw sa pagpapaandar upang iguhit ang bagay. Ang ibabaw ay ang magiging object ng screen na nilikha gamit ang resolusyon nang mas maaga.
def draw (sarili, ibabaw): pygame.draw.circle (ibabaw, itim, (self.x, self.y), self.radius)
Hakbang 3. Gumawa ng isang halimbawa ng klase pati na rin sabihin sa loop ng laro upang iguhit ang bola sa bawat loop
bola = Bola () habang Totoo:… ball.draw (screen)
Hakbang 4. Gawin ang bagay na ilipat
Lumikha ng isang pagpapaandar na mag-a-update sa posisyon ng object. Tawagan ang pagpapaandar na ito sa bawat loop ng laro.
class Ball:… def update (self): self.x + = self.dx self.y + = self.dy
Hakbang 5. Limitahan ang rate ng frame
Talagang mabilis ang paggalaw ng bola dahil tumatakbo ang loop ng laro nang daan-daang beses sa isang segundo. Gamitin ang orasan ni Pygame upang limitahan ang frame rate sa 60 fps.
orasan = pygame.time. Clock () habang Totoo:… orasan.tick (60)
Hakbang 6. Panatilihin ang bola sa screen
Magdagdag ng mga tseke sa pag-andar ng pag-update upang baligtarin ang direksyon ng bola kung na-hit nito ang isa sa mga gilid ng screen.
class Ball:… def update (self):… if (self.x <= 0 or self.x> = resolusyon [0]): self.dx * = -1 kung (self.y <= 0 o self.y > = resolusyon [1]): self.dy * = -1
Hakbang 7. Subukan ito
Narito kung ano ang dapat magmukhang code ngayon:
i-import ang pygame mula sa pygame.locals import * resolusyon = (400, 300) puti = (255, 255, 255) itim = (0, 0, 0) pula = (255, 0, 0) screen = pygame.display.set_mode (resolusyon) klase Ball: def _init _ (self, xPos = resolusyon [0] / 2, yPos = resolusyon [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 (sarili, ibabaw): pygame.draw.circle (ibabaw, itim, (self.x, self.y), self.radius) def update (self): self.x + = self.dx self.y + = self.dy if (self.x <= 0 or self.x> = resolusyon [0]): self.dx * = -1 kung (self.y <= 0 o self.y> = resolusyon [1]): self.dy * = -1 ball = Ball () orasan = pygame.time. Clock () habang True: screen. punan (puti) bola.draw (screen) ball.update () pygame.display.flip () relo.tick (60) para sa kaganapan sa pygame.event.get (): kung event.type == QUIT: pygame.quit ()
Bahagi 4 ng 8: Pagsasaayos ng Laro
Hakbang 1. Gumamit ng mga klase upang ayusin ang lahat
Ang laro ay magiging mas kumplikado. Gumamit ng mga diskarte na nakatuon sa object upang ayusin ang iyong code.
Hakbang 2. Gawing isang klase ang loop ng laro
Dahil ang aming laro ay mayroon nang data kabilang ang iyong mga object at function ng laro, makatuwiran na gawing isang klase ang loop ng iyong laro.
laro ng klase ():
Hakbang 3. Magdagdag ng isang tagapagbuo
Dito mo sisimulan ang ilang mga bagay sa laro, likhain ang aming screen at orasan at isimulan ang Pygame. Kailangang gawing naisasagawa ang Pygame upang magamit ang ilang mga tampok tulad ng teksto o tunog.
class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolusyon) self.clock = pygame.time. Clock ()
Hakbang 4. Pangasiwaan ang mga kaganapan sa isang pagpapaandar
class game ():… def handleEvents (self): para sa kaganapan sa pygame.event.get (): kung event.type == QUIT: pygame.quit ()
Hakbang 5. Gawing gumana ang loop ng laro
Tumawag sa pagpapaandar ng kaganapan sa bawat loop.
class game ():… def run (self): habang True: self.handleEvents () self.screen.fill (white) self.clock.tick (60) pygame.display.flip ()
Hakbang 6. Pangasiwaan ang maraming bagay sa laro
Sa ngayon ang code na ito ay kailangang tumawag sa draw at pag-update sa aming object bawat frame. Magiging magulo ito kung mayroon kang maraming mga bagay. Idagdag natin ang aming object sa isang array at pagkatapos ay i-update at iguhit ang lahat ng mga object sa array bawat loop. Ngayon ay madali mong maidaragdag ang isa pang bagay at bigyan ito ng ibang panimulang posisyon.
class game (): def _init _ (self):… self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))… def run (self): habang Totoo: sarili.handleEvents () para sa gameObj sa sarili.gameObjects: gameObj.update () self.screen.fill (puti) para sa gameObj sa sarili.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip ()
Hakbang 7. Subukan ito
Narito kung ano ang dapat magmukhang code ngayon:
i-import ang pygame mula sa pygame.locals import * resolusyon = (400, 300) puti = (255, 255, 255) itim = (0, 0, 0) pula = (255, 0, 0) screen = pygame.display.set_mode (resolusyon) klase Ball: def _init _ (self, xPos = resolusyon [0] / 2, yPos = resolusyon [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 (sarili, ibabaw): pygame.draw.circle (ibabaw, itim, (self.x, self.y), self.radius) def update (self): self.x + = self.dx self.y + = self.dy if (self.x <= 0 or self.x> = resolusyon [0]): self.dx * = -1 kung (self.y <= 0 o self.y> = resolusyon [1]): self.dy * = -1 class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolusyon) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (sarili): para sa kaganapan sa pygame.event.get (): kung event.type == QUIT: pygame.quit () def run (self): habang True: self.handleEvent s () para sa gameObj sa sarili.gameObjects: gameObj.update () self.screen.fill (puti) para sa gameObj sa sarili.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display. pitik () laro (). patakbuhin ()
Bahagi 5 ng 8: Pagdaragdag ng isang object ng Player
Hakbang 1. Gumawa ng klase ng manlalaro at tagapagbuo
Gagawa ka ng isa pang bilog na kinokontrol ng mouse. Pasimulan ang mga halaga sa tagabuo. Ang radius ang tanging mahalagang halaga.
klase Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Hakbang 2. Tukuyin kung paano iguhit ang object ng manlalaro
Ito ay magiging katulad ng pagguhit mo sa iba pang mga object ng laro.
class Player:… def draw (sarili, ibabaw): pygame.draw.circle (ibabaw, pula, (self.x, self.y), self.radius)
Hakbang 3. Magdagdag ng kontrol sa mouse para sa object ng player
Sa bawat frame, suriin ang lokasyon ng mouse at itakda ang lokasyon ng mga object ng mga manlalaro sa puntong iyon.
class Player:… def update (self): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1]
Hakbang 4. Magdagdag ng isang object ng manlalaro sa mga gameObjects
Lumikha ng isang bagong halimbawa ng manlalaro at idagdag ito sa listahan.
class game (): def _init _ (self):… self.gameObjects.append (Player ())
Hakbang 5. Subukan ito
Narito kung ano ang dapat magmukhang code ngayon:
i-import ang pygame mula sa pygame.locals import * resolusyon = (400, 300) puti = (255, 255, 255) itim = (0, 0, 0) pula = (255, 0, 0) screen = pygame.display.set_mode (resolusyon) klase Ball: def _init _ (self, xPos = resolusyon [0] / 2, yPos = resolusyon [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 (sarili, ibabaw): pygame.draw.circle (ibabaw, itim, (self.x, self.y), self.radius) def update (self): self.x + = self.dx self.y + = self.dy if (self.x <= 0 or self.x> = resolusyon [0]): self.dx * = -1 kung (self.y <= 0 o self.y> = resolusyon [1]): self.dy * = -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (sarili, ibabaw): pygame.draw.circle (ibabaw, pula, (self.x, self.y), self.radius) def update (self): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_ mode (resolusyon) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): para sa kaganapan sa pygame.event.get (): kung event.type == QUIT: pygame.quit () def run (self): habang True: self.handleEvents () para sa gameObj sa sarili.gameObjects: gameObj.update () self.screen.fill (puti) para sa gameObj sa sarili.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). patakbuhin ()
Bahagi 6 ng 8: Paggawa ng Mga Bagay na Nakikipag-ugnay sa Manlalaro
Hakbang 1. Baguhin ang mga pagpapaandar sa Pag-update
Upang makapag-ugnay ang mga bagay, kailangan nilang magkaroon ng access sa bawat isa. Magdagdag tayo ng isa pang parameter sa I-update upang maipasa sa listahan ng gameObjects. Kailangan mong idagdag ito sa parehong object ng manlalaro at mga Ball object. Kung mayroon kang maraming mga bagay sa laro, ang mana ay maaaring makatulong sa iyo na panatilihing pareho ang lahat ng iyong mga lagda sa pamamaraan.
class Ball:… def update (self, gameObjects):… class Player:… def update (self, gameObjects):
Hakbang 2. Suriin ang mga banggaan sa pagitan ng manlalaro at mga bola
Dumaan sa lahat ng mga object ng laro at suriin kung ang uri ng mga object ay bola. Pagkatapos ay gamitin ang radii ng dalawang bagay at ang pormula ng distansya upang suriin kung nakabangga ang mga ito. Ang mga bilog ay talagang madaling suriin ang mga banggaan. Ito ang pinakamalaking dahilan na hindi ka gumamit ng ibang mga hugis para sa larong ito.
class Player:… def update (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:
Hakbang 3. Tapusin ang laro kung ang "manlalaro" ay natamaan
Hinahayaan lang nating umalis sa laro sa ngayon.
kung (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
Hakbang 4. Subukan ito
Narito Kung ano ang magiging hitsura ng code ngayon:
i-import ang pygame mula sa pygame.locals import * resolusyon = (400, 300) puti = (255, 255, 255) itim = (0, 0, 0) pula = (255, 0, 0) screen = pygame.display.set_mode (resolusyon) klase Ball: def _init _ (self, xPos = resolusyon [0] / 2, yPos = resolusyon [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 (sarili, ibabaw): pygame.draw.circle (ibabaw, itim, (self.x, self.y), self.radius) pag-update ng def (sarili, gameObjects): self.x + = self.dx self.y + = self.dy kung (self.x <= 0 o self.x> = resolusyon [0]): sarili.dx * = -1 kung (self.y <= 0 o self.y> = resolusyon [1]): self.dy * = -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (sarili, ibabaw): pygame.draw.circle (ibabaw, pula, (self.x, self.y), self.radius) def update (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] para sa gameObj sa gameObjects: kung gameObj.type == "bola": kung (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolusyon) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): para sa kaganapan sa pygame.event.get (): kung event.type == QUIT: pygame.quit () def run (sarili): habang Totoo: self.handleEvents () para sa gameObj sa sarili.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (puti) para sa gameObj sa sarili.gameObjects: gameObj.draw [self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Bahagi 7 ng 8: Pagdaragdag ng isang Game Controller upang Lumikha ng Mga Bagay
Hakbang 1. Lumikha ng isang klase ng game controller
Responsable ang mga Game Controller para sa "pagpapatakbo" ng laro. Ito ay naiiba mula sa aming klase ng laro na responsable para sa pagguhit at pag-update ng lahat ng aming mga object. Pana-panahong idaragdag ng controller ang isa pang bola sa screen upang gawing mas mahirap ang laro. Magdagdag ng isang tagapagbuo at simulan ang ilang pangunahing mga halaga. Ang agwat ay ang oras bago idagdag ang isa pang bola.
class GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "game controller"
Hakbang 2. Idagdag ang pagpapaandar sa pag-update
Susuriin nito kung gaano karaming oras ang lumipas mula nang magdagdag ng bola o mula sa pagsisimula ng laro. Kung ang oras ay higit pa sa agwat ay ire-reset mo ang oras at magdagdag ng isang bola.
class GameController:… def update (self, gameObjects): kung self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball ())
Hakbang 3. Bigyan ang mga bola ng mga random na bilis
Kakailanganin mong gumamit ng mga random na numero upang magkakaiba ang laro sa bawat oras. Gayunpaman, ang mga bilis ng bola ay isang lumulutang point number sa halip na isang integer.
class GameController:… def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball (xVel = random () * 2, yVel = random () * 2))
Hakbang 4. Ayusin ang paggana ng pagguhit
Hindi tatanggapin ang paggana ng pagguhit ng mga float. I-convert natin ang posisyon ng bola sa mga integer bago iguhit ang mga bola.
class Ball:… def draw (sarili, ibabaw): pygame.draw.circle (ibabaw, itim, (int (self.x), int (self.y)), self.radius)
Hakbang 5. Tukuyin ang isang paraan ng pagguhit para sa game controller
Dahil ito ay isang object ng laro, susubukan ng pangunahing loop na iguhit ito. Kakailanganin mong tukuyin ang isang paggana ng pagguhit na walang ginagawa upang ang laro ay hindi nag-crash.
klase GameController:… def draw (sarili, screen): pumasa
Hakbang 6. Idagdag ang game controller sa mga gameObjects at alisin ang 2 bola
Dapat na ngayon ang laro ng isang bola bawat limang segundo.
class game (): def _init _ (self):… self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
Hakbang 7. Subukan ito
Narito kung ano ang dapat magmukhang code ngayon:
mag-import ng pygame mula sa random na random na pag-import mula sa pygame.locals import * resolusyon = (400, 300) puti = (255, 255, 255) itim = (0, 0, 0) pula = (255, 0, 0) screen = pygame. display.set_mode (resolusyon) klase Bola: def _init _ (sarili, xPos = resolusyon [0] / 2, yPos = resolusyon [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 (sarili, ibabaw): pygame.draw.circle (ibabaw, itim, (int (sarili. x), int (self.y)), self.radius) def update (sarili, gameObjects): self.x + = self.dx self.y + = self.dy kung (self.x <= 0 o sarili. x> = resolusyon [0]): self.dx * = -1 kung (self.y <= 0 o self.y> = resolusyon [1]): self.dy * = -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (sarili, ibabaw): pygame.draw.circle (ibabaw, pula, (self.x, self.y), self.radius) def update (sarili, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] para sa gameObj sa laro Mga Bagay: kung gameObj.type == "bola": kung (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) * * 2: pygame.quit () class GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "game controller "def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball (xVel = random () * 2, yVel = random () * 2)) def draw (self, screen): pass class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolusyon) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) def handleEvents (self): para sa kaganapan sa pygame.event.get (): kung event.type == QUIT: pygame.quit () def run (self): habang True: self.handleEvents () para sa gameObj sa sarili.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (puti) para sa gameObj sa sarili.gameO bjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
Bahagi 8 ng 8: Pagdaragdag ng isang Iskor at Game Over
Hakbang 1. Magdagdag ng isang marka sa klase ng game controller
Lumikha ng isang object ng font at variable ng iskor. Iguhit mo ang font sa bawat frame upang ipakita ang iskor at dagdagan ang iskor sa bawat frame sa pag-update.
class GameController: def _init _ (self, interval = 5):… self.score = 0 self.scoreText = pygame. font. Font (Wala, 12) def update (sarili, gameObjects):… self.score + = 1 def draw (self, screen): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5))
Hakbang 2. Baguhin kung paano nagtatapos ang laro
Tanggalin natin ang quit kapag nakita ng manlalaro ang isang banggaan. Sa halip magtatakda ka ng isang variable sa player na maaaring suriin ng laro. Kapag itinakda ang gameOver, ihinto ang pag-update ng mga object. I-freeze nito ang lahat sa lugar upang makita ng manlalaro kung ano ang nangyari at suriin ang kanilang iskor. Tandaan na ang mga bagay ay iginuhit pa rin, hindi pa na-update.
class Player: def _init _ (self, rad = 20):… self.gameOver = Maling pag-update ng def (sarili, gameObjects): … para sa gameObj sa gameObjects: kung gameObj.type == "bola": kung (gameObj.x - sarili.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = True class game (): def _init _ (self): … Self.gameOver = Maling def run (sarili): habang Totoo: self.handleEvents () kung hindi self.gameOver: para sa gameObj sa sarili.gameObjects: gameObj.update (self.gameObjects) kung gameObj.type == "player": self.gameOver = gameObj.gameOver
Hakbang 3. Subukan ito
Narito kung ano ang magiging hitsura ng natapos na code ngayon:
i-import ang pygame mula sa random na random na pag-import mula sa pygame.locals import * resolusyon = (400, 300) puti = (255, 255, 255) itim = (0, 0, 0) pula = (255, 0, 0) screen = pygame. display.set_mode (resolusyon) klase Bola: def _init _ (sarili, xPos = resolusyon [0] / 2, yPos = resolusyon [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 (sarili, ibabaw): pygame.draw.circle (ibabaw, itim, (int (sarili. x), int (self.y)), self.radius) def update (sarili, gameObjects): self.x + = self.dx self.y + = self.dy kung (self.x <= 0 o sarili. x> = resolusyon [0]): self.dx * = -1 kung (self.y <= 0 o self.y> = resolusyon [1]): self.dy * = -1 class Player: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" self.gameOver = Maling def draw (sarili, ibabaw): pygame.draw.circle (ibabaw, pula, (self.x, self.y), self.radius) def update (sarili, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] para sa gameObj sa gameObjects: kung gameObj.type == "bola": kung (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = True class GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self. type = "game controller" self.score = 0 self.scoreText = pygame. font. Font (Wala, 12) def update (sarili, gameObjects): kung self.next <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), True, black), (5, 5)) class game (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resolusyon) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) self.gameOver = False def handleEvents (sarili): para sa kaganapan sa pygame.event.get (): kung ev ent.type == QUIT: pygame.quit () def run (self): habang True: self.handleEvents () kung hindi self.gameOver: para sa gameObj sa sarili.gameObjects: gameObj.update (self.gameObjects) kung gameObj. type == "player": self.gameOver = gameObj.gameOver self.screen.fill (puti) para sa gameObj sa sarili.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () laro (). patakbuhin ()
