Tämä on johdanto Pygameen ihmisille, jotka jo tuntevat Pythonin. Tämä artikkeli opettaa sinulle vaiheet yksinkertaisen pelin rakentamiseen, jossa pelaaja väistää pomppivia palloja.
Askeleet
Osa 1/8: Pygamen asennus
Vaihe 1. Lataa Pygame
Löydä se alustallesi osoitteesta
Vaihe 2. Suorita asennusohjelma
Vaihe 3. Tarkista, että asennus toimi
Avaa Python -pääte. Kirjoita "Tuo pygame". Jos et näe virheitä, Pygame asennettiin onnistuneesti.
tuoda pygame
Osa 2/8: Perusikkunan asettaminen
Vaihe 1. Avaa uusi tiedosto
Vaihe 2. Tuo Pygame
Pygame on kirjasto, joka tarjoaa pääsyn grafiikkatoimintoihin. Jos haluat lisätietoja näiden toimintojen toiminnasta, voit etsiä ne Pygame -verkkosivustolta.
tuo pygame pygame.locals -tuonnista *
Vaihe 3. Aseta ikkunan resoluutio
Teet globaalin muuttujan näytön tarkkuudelle, jotta siihen voidaan viitata useissa pelin osissa. Se on myös helppo löytää tiedoston yläosasta, joten sitä voidaan muuttaa myöhemmin. Edistyneissä hankkeissa näiden tietojen sijoittaminen erilliseen tiedostoon olisi parempi idea.
resoluutio = (400, 300)
Vaihe 4. Määritä joitakin värejä
Pygame -värit ovat (RBGA, jonka arvot vaihtelevat välillä 0 ja 255. Alfa -arvo (A) on valinnainen, mutta muut värit (punainen, sininen ja vihreä ovat pakollisia).
valkoinen = (255, 255, 255) musta = (0, 0, 0) punainen = (255, 0, 0)
Vaihe 5. Alusta näyttö
Käytä aiemmin määriteltyä resoluutiomuuttujaa.
screen = pygame.display.set_mode (resoluutio)
Vaihe 6. Tee pelisilmukka
Toista tietyt toiminnot pelimme jokaisessa kehyksessä. Tee silmukka, joka toistuu aina kaikkien näiden toimintojen läpi.
vaikka totta:
Vaihe 7. Väritä näyttö
screen.fill (valkoinen)
Vaihe 8. Näytä näyttö
Jos suoritat ohjelman, näyttö muuttuu valkoiseksi ja ohjelma kaatuu. Tämä johtuu siitä, että käyttöjärjestelmä lähettää tapahtumia peliin eikä peli tee mitään niiden kanssa. Kun peli vastaanottaa liikaa käsittelemättömiä tapahtumia, se kaatuu.
Vaikka totta:… pygame.display.flip ()
Vaihe 9. Käsittele tapahtumia
Hanki luettelo kaikista tapahtumista, jotka ovat tapahtuneet kussakin kehyksessä. Välität vain yhdestä tapahtumasta, lopettamistapahtumasta. Tämä tapahtuu, kun käyttäjä sulkee peli -ikkunan. Tämä estää myös ohjelmamme kaatumasta liian monien tapahtumien vuoksi.
kun taas True:… tapahtumalle pygame.event.get (): if event.type == QUIT: pygame.quit ()
Vaihe 10. Kokeile
Tältä koodin pitäisi näyttää nyt:
tuo pygame pygame.localsista tuonti * resoluutio = (400, 300) valkoinen = (255, 255, 255) musta = (0, 0, 0) punainen = (255, 0, 0) screen = pygame.display.set_mode (tarkkuus) kun taas True: screen.fill (valkoinen) pygame.display.flip () tapahtumalle pygame.event.get (): if event.type == QUIT: pygame.quit ()
Osa 3/8: Peliobjektin tekeminen
Vaihe 1. Luo uusi luokka ja rakentaja
Aseta kaikki objektin ominaisuudet. Annat myös oletusarvot kaikille ominaisuuksille.
luokan pallo: def _init _ (itse, xPos = resoluutio [0] / 2, yPos = resoluutio [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 = "pallo"
Vaihe 2. Määritä, miten objekti piirretään
Käytä konstruktorissa määriteltyjä ominaisuuksia piirtääksesi pallo ympyräksi ja välittämällä pinnan kohteen piirtämiseen. Pinta on näytön objekti, joka luotiin aiemmin tarkkuudella.
def draw (itse, pinta): pygame.draw.circle (pinta, musta, (self.x, self.y), self.radius)
Vaihe 3. Tee luokan esiintymä ja kerro pelisilmukalle, että se vetää pallon jokaiseen silmukkaan
pallo = pallo (), kun taas totta:… ball.draw (näyttö)
Vaihe 4. Anna kohteen liikkua
Luo toiminto, joka päivittää objektin sijainnin. Kutsu tämä toiminto jokaiseen pelisilmukkaan.
luokan pallo:… def päivitys (itse): self.x += self.dx self.y += self.dy
Vaihe 5. Rajoita kuvataajuutta
Pallo liikkuu todella nopeasti, koska pelisilmukka kulkee satoja kertoja sekunnissa. Käytä Pygamen kelloa rajoittaaksesi kuvataajuuden 60 kuvaan sekunnissa.
clock = pygame.time. Clock () kun True:… clock.tick (60)
Vaihe 6. Pidä pallo näytöllä
Lisää tarkistuksia päivitystoimintoon, jos haluat kääntää pallon suunnan, jos se osuu johonkin näytön reunaan.
luokan pallo:… def päivitys (itse):… jos (itse.x <= 0 tai itse.x> = resoluutio [0]): itse.dx *= -1 jos (itse.y <= 0 tai itse.y > = resoluutio [1]): self.dy *= -1
Vaihe 7. Kokeile
Tältä koodin pitäisi näyttää nyt:
tuo pygame pygame.localsista tuonti * resoluutio = (400, 300) valkoinen = (255, 255, 255) musta = (0, 0, 0) punainen = (255, 0, 0) screen = pygame.display.set_mode (resoluutio) luokka Ball: def _init _ (itse, xPos = resoluutio [0] / 2, yPos = resoluutio [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 (itse, pinta): pygame.draw.circle (pinta, musta, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resoluutio [0]): self.dx *= -1 jos (self.y <= 0 tai self.y> = resoluutio [1]): self.dy *= -1 pallo = Ball () kello = peli -aika. Kello () kun True: näyttö. täytä (valkoinen) pallo.piirrä (näyttö) pallo. ()
Osa 4/8: Pelin järjestäminen
Vaihe 1. Järjestä kaikki luokkien avulla
Peli muuttuu monimutkaisemmaksi. Järjestä koodisi objektipohjaisilla tekniikoilla.
Vaihe 2. Tee pelisilmukka luokkaan
Koska pelissämme on nyt tietoja, mukaan lukien peliobjektisi ja -toimintosi, on järkevää muuttaa pelisilmukka luokkaan.
luokan peli ():
Vaihe 3. Lisää rakentaja
Täällä tulet näyttämään joitakin peliobjekteja, luomaan näytön ja kellon ja alustamaan Pygame. Pygame on alustettava käyttämään tiettyjä ominaisuuksia, kuten tekstiä tai ääntä.
luokan peli (): def _init _ (itse): pygame.init () self.screen = pygame.display.set_mode (resoluutio) self.clock = pygame.time. Clock ()
Vaihe 4. Käsittele tapahtuman tapahtumia
luokan peli ():… def handleEvents (itse): tapahtumalle pygame.event.get (): if event.type == QUIT: pygame.quit ()
Vaihe 5. Tee pelisilmukasta toiminto
Soita tapahtumakäsittelytoiminto joka silmukka.
luokan peli ():… def run (self): kun True: self.handleEvents () self.screen.fill (valkoinen) self.clock.tick (60) pygame.display.flip ()
Vaihe 6. Käsittele useita peliobjekteja
Tällä hetkellä tämän koodin on kutsuttava piirtämään ja päivittämään objektiimme jokainen kehys. Tämä menisi sekaisin, jos sinulla olisi paljon esineitä. Lisäämme objektimme taulukkoon ja päivitämme ja piirrämme sitten kaikki taulukon objektit jokaisen silmukan. Nyt voit helposti lisätä toisen kohteen ja antaa sille toisen lähtöasennon.
luokan peli (): def _init _ (itse):… self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))… def run (self): kun 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.voltti()
Vaihe 7. Kokeile
Tältä koodin pitäisi näyttää nyt:
tuo pygame pygame.localsista tuonti * resoluutio = (400, 300) valkoinen = (255, 255, 255) musta = (0, 0, 0) punainen = (255, 0, 0) screen = pygame.display.set_mode (resoluutio) luokka Ball: def _init _ (itse, xPos = resoluutio [0] / 2, yPos = resoluutio [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 (itse, pinta): pygame.draw.circle (pinta, musta, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resoluutio [0]): self.dx *= -1 jos (self.y <= 0 tai self.y> = resoluutio [1]): self.dy *= -1 luokan peli (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resoluutio) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): tapahtumalle pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): kun 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. flip () peli (). run ()
Osa 5/8: Pelaajaobjektin lisääminen
Vaihe 1. Tee pelaajaluokka ja rakentaja
Teet toisen ympyrän, jota hiiri ohjaa. Alusta arvot konstruktorissa. Säde on ainoa tärkeä arvo.
luokan pelaaja: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Vaihe 2. Määritä, miten pelaajaobjekti piirretään
Se tulee olemaan samalla tavalla kuin muut peliesineet.
luokan pelaaja:… def draw (itse, pinta): pygame.draw.circle (pinta, punainen, (self.x, self.y), self.radius)
Vaihe 3. Lisää hiiren ohjain soitinobjektille
Tarkista jokaisessa kehyksessä hiiren sijainti ja aseta pelaajien kohteiden sijainti tähän pisteeseen.
luokan pelaaja:… def update (self): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1]
Vaihe 4. Lisää pelaajaobjekti gameObjectsiin
Luo uusi pelaaja -ilmentymä ja lisää se luetteloon.
luokan peli (): def _init _ (itse):… self.gameObjects.append (Pelaaja ())
Vaihe 5. Kokeile
Tältä koodin pitäisi näyttää nyt:
tuo pygame pygame.localsista tuonti * resoluutio = (400, 300) valkoinen = (255, 255, 255) musta = (0, 0, 0) punainen = (255, 0, 0) screen = pygame.display.set_mode (resoluutio) luokka Ball: def _init _ (itse, xPos = resoluutio [0] / 2, yPos = resoluutio [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 (itse, pinta): pygame.draw.circle (pinta, musta, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resoluutio [0]): self.dx *= -1 jos (self.y <= 0 tai self.y> = resoluutio [1]): self.dy *= -1 luokka Pelaaja: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (itse, pinta): pygame.draw.circle (pinta, punainen, (self.x, self.y), self.radius) def update (itse): johto = pygame.mouse.get_pos () self.x = johto [0] self.y = johto [1] luokan peli (): def _init _ (itse): pygame.init () self.screen = pygame.display.set_ tila (resoluutio) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))) def handleEvents (self): tapahtumalle pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): kun True: self.handleEvents () gameObj itse.gameObjects: gameObj.update () self.screen.fill (valkoinen) pelilleObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () peli (). juosta()
Osa 6/8: Esineiden vuorovaikutus pelaajan kanssa
Vaihe 1. Muuta päivitystoimintoja
Jotta esineet voivat olla vuorovaikutuksessa, niiden on päästävä toisiinsa. Lisätään toinen parametri päivitettäväksi GameObjects -luetteloon. Sinun on lisättävä se sekä pelaaja- että Ball -esineisiin. Jos sinulla on paljon peliobjekteja, perintö voi auttaa sinua pitämään kaikki metodisi allekirjoitukset samana.
luokan pallo:… def päivitys (itse, gameObjects):… luokan pelaaja:… def päivitys (itse, gameObjects):
Vaihe 2. Tarkista pelaajan ja pallojen väliset törmäykset
Käy läpi kaikki peliobjektit ja tarkista, onko niiden tyyppi pallo. Tarkista sitten kahden kohteen säteet ja etäisyyskaava, törmäävätkö ne. Piireissä on todella helppo tarkistaa törmäykset. Tämä on suurin syy, miksi et käyttänyt muuta muotoa tähän peliin.
luokan pelaaja:… def päivitys (itse, gameObjects):… pelilleOBJ pelissäObjects: jos gameObj.type == "pallo": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (peliObj.säde + itse säde) ** 2:
Vaihe 3. Lopeta peli, jos pelaaja saa "osuman"
Lopetetaan vain peli toistaiseksi.
if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
Vaihe 4. Kokeile
Tältä koodin pitäisi näyttää nyt:
tuo pygame pygame.localsista tuonti * resoluutio = (400, 300) valkoinen = (255, 255, 255) musta = (0, 0, 0) punainen = (255, 0, 0) screen = pygame.display.set_mode (resoluutio) luokka Ball: def _init _ (itse, xPos = resoluutio [0] / 2, yPos = resoluutio [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 (itse, pinta): pygame.draw.circle (pinta, musta, (self.x, self.y), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = resoluutio [0]): self.dx *= -1 jos (self.y <= 0 tai self.y> = resoluutio [1]): self.dy *= -1 luokka Pelaaja: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (itse, pinta): pygame.draw.circle (pinta, punainen, (self.x, self.y), self.radius) def päivitys (itse, gameObjects): johto = pygame.mouse.get_pos () self.x = johto [0] self.y = johto [1] gameObj: lle gameObjectsissa: jos gameObj.type == "pallo": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () luokan peli (): def _init _ (itse): pygame.init () self.screen = pygame.display.set_mode (resoluutio) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): tapahtumaan 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 () peli (). run ()
Osa 7/8: Peliohjaimen lisääminen objektien luomiseen
Vaihe 1. Luo peliohjainluokka
Pelin ohjaimet ovat vastuussa pelin "suorittamisesta". Se eroaa peliluokastamme, joka on vastuussa kaikkien kohteidemme piirtämisestä ja päivittämisestä. Ohjain lisää säännöllisesti toisen pallon näytölle vaikeuttaakseen peliä. Lisää konstruktori ja alusta joitakin perusarvoja. Aikaväli on aika ennen uuden pallon lisäämistä.
luokka GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "peliohjain"
Vaihe 2. Lisää päivitystoiminto
Tämä tarkistaa, kuinka paljon aikaa on kulunut pallon lisäämisestä tai pelin alusta. Jos aika on pidempi kuin aikaväli, nollaat ajan ja lisäät pallon.
luokan GameController:… def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball ())
Vaihe 3. Anna palloille satunnaiset nopeudet
Sinun on käytettävä satunnaislukuja tehdäksesi pelistä erilaisen joka kerta. Kuitenkin pallojen nopeudet ovat nyt liukuluku luku kokonaisluvun sijasta.
luokan 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 = satunnainen ()*2, yVel = satunnainen ()*2))
Vaihe 4. Korjaa piirtotoiminto
Tasapeli ei hyväksy kellukkeita. Muunnetaan pallon sijainti kokonaislukuiksi ennen kuin pallot vedetään.
luokan pallo:… def draw (itse, pinta): pygame.draw.circle (pinta, musta, (int (self.x), int (self.y)), self.radius)
Vaihe 5. Määritä peliohjaimen tasapeli
Koska se on peliobjekti, pääsilmukka yrittää piirtää sen. Sinun on määritettävä piirtotoiminto, joka ei tee mitään, jotta peli ei kaatuisi.
luokan GameController:… def draw (itse, näyttö): pass
Vaihe 6. Lisää peliohjain gameObjectsiin ja poista 2 palloa
Pelin pitäisi nyt saada pallo viiden sekunnin välein.
luokan peli (): def _init _ (itse):… self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
Vaihe 7. Kokeile
Tältä koodin pitäisi näyttää nyt:
tuo pygame satunnaisesta tuonnista satunnaisesti pygamesta. paikalliset tuonti * resoluutio = (400, 300) valkoinen = (255, 255, 255) musta = (0, 0, 0) punainen = (255, 0, 0) screen = pygame. display.set_mode (resoluutio) luokka Ball: def _init _ (itse, xPos = resoluutio [0] / 2, yPos = resoluutio [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 (itse, pinta): pygame.draw.circle (pinta, musta, (int (its.) x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 tai self.) x> = resoluutio [0]): self.dx *= -1 jos (self.y <= 0 tai self.y> = resoluutio [1]): self.dy *= -1 luokka Pelaaja: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (itse, pinta): pygame.draw.circle (pinta, punainen, (self.x), self.y), self.radius) def update (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] gameObj -pelissä Objektit: jos gameObj.type == "pallo": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius)* * 2: pygame.quit () luokka GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "peliohjain "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 = satunnainen ()*2)) def draw (itse, näyttö): pass luokan peli (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (päätöslauselma) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) def handleEvents (self): tapahtumaan pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): kun True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update (self.gameObjects) self.screen.täytä (valkoinen) gameObj: lle itse. gameO bjects: gameObj.draw (itsenäyttö) self.clock.tick (60) pygame.display.flip () peli (). run ()
Osa 8/8: Pisteiden lisääminen ja pelin päättyminen
Vaihe 1. Lisää pisteet peliohjaimen luokkaan
Luo kirjasinobjekti ja pistemuuttuja. Piirrät fontin jokaiseen kehykseen näyttääksesi pisteet ja kasvattaaksesi pisteitä jokaisen päivityksen yhteydessä.
luokan GameController: def _init _ (itse, väli = 5):… self.pisteet = 0 self.scoreText = pygame.font. Font (Ei mitään, 12) def update (self, gameObjects):… self.pisteet += 1 def draw (itse, näyttö): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5))
Vaihe 2. Muokkaa miten peli päättyy
Päästä eroon lopettamisesta, kun pelaaja havaitsee törmäyksen. Sen sijaan asetat pelaajaan muuttujan, jonka peli voi tarkistaa. Kun gameOver on asetettu, lopeta objektien päivittäminen. Tämä jäädyttää kaiken paikallaan, jotta pelaaja voi nähdä mitä tapahtui ja tarkistaa pisteet. Huomaa, että objektit piirretään edelleen, mutta niitä ei päivitetä.
luokan pelaaja: def _init _ (self, rad = 20):… self.gameOver = Väärä def -päivitys (self, gameObjects):… gameObj: lle gameObjectsissa: if gameObj.type == "pallo": if (gameObj.x - itse.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = True class game (): def _init _ (self): … Self.gameOver = Väärä def run (self): kun True: self.handleEvents () ellei self.gameOver: gameObj: lle itsessä.gameObjects: gameObj.update (self.gameObjects) jos gameObj.type == "player": self.gameOver = gameObj.gameOver
Vaihe 3. Kokeile
Lopullisen koodin pitäisi näyttää nyt tältä:
tuo pygame satunnaisesta tuonnista satunnaisesti pygamesta. paikalliset tuonti * resoluutio = (400, 300) valkoinen = (255, 255, 255) musta = (0, 0, 0) punainen = (255, 0, 0) screen = pygame. display.set_mode (resoluutio) luokka Ball: def _init _ (itse, xPos = resoluutio [0] / 2, yPos = resoluutio [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 (itse, pinta): pygame.draw.circle (pinta, musta, (int (itse.) x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 tai self.) x> = resoluutio [0]): self.dx *= -1 jos (self.y <= 0 tai self.y> = resoluutio [1]): self.dy *= -1 luokka Pelaaja: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" self.gameOver = False def draw (self, pinta): pygame.draw.circle (pinta, punainen), (self.x, self.y), self.radius) def update (self, gameObjects): johto = pygame.mouse.get_pos () self.x = johto [0] self.y = johto [1] gameObj: lle gameObjects: jos gameObj.type == "pallo": if (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 = intervalli self.next = pygame.time.get_ticks () + (2*1000) self. type = "peliohjain" self.score = 0 self.scoreText = pygame.font. Font (None, 12) 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)) self.score + = 1 def draw (itse, näyttö): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5)) luokan peli (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (resoluutio) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) self.gameOver = False def handleEvents (itse): tapahtumaan pygame.event.get (): jos ev ent.type == QUIT: pygame.quit () def run (self): kun True: self.handleEvents () jos ei self.gameOver: gameObj in self.gameObjects: gameObj.update (self.gameObjects) jos gameObj. type == "player": self.gameOver = gameObj.gameOver self.screen.fill (white) for gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () peli (). juokse ()
