Tai įvadas į „Pygame“žmonėms, kurie jau žino „Python“. Šis straipsnis išmokys jus, kaip sukurti paprastą žaidimą, kurio metu žaidėjas vengia atšokusių kamuolių.
Žingsniai
1 dalis iš 8: „Pygame“diegimas
Žingsnis 1. Atsisiųskite „Pygame“
Raskite ją savo platformai iš
Žingsnis 2. Paleiskite diegimo programą
Žingsnis 3. Patikrinkite, ar diegimas veikė
Atidarykite „Python“terminalą. Įveskite „importuoti žaidimą“. Jei nematote klaidų, „Pygame“buvo sėkmingai įdiegta.
importuoti žaidimą
2 dalis iš 8: Pagrindinio lango nustatymas
Žingsnis 1. Atidarykite naują failą
2 veiksmas. Importuokite „Pygame“
„Pygame“yra biblioteka, suteikianti prieigą prie grafikos funkcijų. Jei norite gauti daugiau informacijos apie tai, kaip šios funkcijos veikia, galite jų ieškoti „Pygame“svetainėje.
importuoti pygame iš pygame.locals import *
Žingsnis 3. Nustatykite lango skiriamąją gebą
Sukursite visuotinį ekrano skiriamosios gebos kintamąjį, kad jį būtų galima nurodyti keliose žaidimo dalyse. Jį taip pat lengva rasti failo viršuje, kad vėliau jį būtų galima pakeisti. Pažangiems projektams geriau būtų šią informaciją sudėti į atskirą failą.
rezoliucija = (400, 300)
Žingsnis 4. Apibrėžkite kai kurias spalvas
„Pygame“spalvos yra (RBGA, kurios reikšmės svyruoja nuo 0 iki 255. Alfa reikšmė (A) yra neprivaloma, tačiau kitos spalvos (raudona, mėlyna ir žalia) yra privalomos.
balta = (255, 255, 255) juoda = (0, 0, 0) raudona = (255, 0, 0)
Žingsnis 5. Inicijuokite ekraną
Naudokite anksčiau apibrėžtą skiriamosios gebos kintamąjį.
ekranas = pygame.display.set_mode (raiška)
Žingsnis 6. Sukurkite žaidimo kilpą
Pakartokite tam tikrus veiksmus kiekviename mūsų žaidimo kadre. Sukurkite ciklą, kuris visada kartosis, kad būtų galima atlikti visus šiuos veiksmus.
nors tiesa:
Žingsnis 7. Spalvokite ekraną
screen.fill (balta)
Žingsnis 8. Parodykite ekraną
Jei paleisite programą, ekranas taps baltas, o tada programa suges. Taip yra todėl, kad operacinė sistema siunčia į žaidimą įvykius ir žaidimas su jais nieko nedaro. Kai žaidimas gaus per daug neapdorotų įvykių, jis suges.
nors tiesa:… pygame.display.flip ()
Žingsnis 9. Tvarkykite įvykius
Gaukite visų įvykių, įvykusių kiekviename kadre, sąrašą. Jums rūpi tik vienas įvykis - nutraukimo įvykis. Tai atsitinka, kai vartotojas uždaro žaidimo langą. Tai taip pat neleis mūsų programai sugesti dėl per daug įvykių.
nors tiesa:… renginiui pygame.event.get (): if event.type == QUIT: pygame.quit ()
Žingsnis 10. Išbandykite
Štai kaip dabar turėtų atrodyti kodas:
importuoti pygame iš pygame.locals importuoti * rezoliuciją = (400, 300) balta = (255, 255, 255) juoda = (0, 0, 0) raudona = (255, 0, 0) ekraną = pygame.display.set_mode (rezoliucija), nors tiesa: screen.fill (balta) pygame.display.flip () įvykis pygame.event.get (): if event.type == QUIT: pygame.quit ()
3 dalis iš 8: Žaidimo objekto kūrimas
1 žingsnis. Sukurkite naują klasę ir konstruktorių
Nustatykite visas objekto savybes. Taip pat pateikiate numatytas visų nuosavybių vertes.
klasės kamuolys: def _init _ (self, xPos = rezoliucija [0] / 2, yPos = rezoliucija [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 = "kamuolys"
Žingsnis 2. Apibrėžkite, kaip nupiešti objektą
Naudokite konstruktoriuje apibrėžtas savybes, norėdami piešti rutulį kaip apskritimą, taip pat perduoti paviršių į funkciją, kuria piešiamas objektas. Paviršius bus ekrano objektas, sukurtas naudojant ankstesnę skiriamąją gebą.
def atkreipti (save, paviršių): pygame.draw.circle (paviršius, juodas, (self.x, self.y), self.radius)
3 žingsnis. Padarykite klasės egzempliorių ir pasakykite žaidimo kilpai, kad kiekvienoje kilpoje būtų nupieštas kamuolys
kamuolys = kamuolys (), o tiesa:… ball.draw (ekranas)
Žingsnis 4. Priverskite objektą judėti
Sukurkite funkciją, kuri atnaujins objekto padėtį. Paskambinkite šiai funkcijai kiekviename žaidimo cikle.
klasės kamuolys:… def atnaujinimas (save): self.x += self.dx self.y += self.dy
Žingsnis 5. Apribokite kadrų dažnį
Kamuolys judės tikrai greitai, nes žaidimo kilpa sukasi šimtus kartų per sekundę. Naudokite „Pygame“laikrodį, kad apribotumėte kadrų dažnį iki 60 kadrų per sekundę.
laikrodis = pygame.time. Clock (), o tiesa:… clock.tick (60)
Žingsnis 6. Laikykite kamuolį ekrane
Atnaujinimo funkcijoje pridėkite čekių, kad pakeistumėte rutulio kryptį, jei jis atsitrenkia į vieną iš ekrano kraštų.
klasės kamuolys:… def atnaujinimas (savarankiškai):… jei (self.x <= 0 arba self.x> = rezoliucija [0]): self.dx *= -1, jei (self.y <= 0 arba self.y > = raiška [1]): self.dy *= -1
Žingsnis 7. Išbandykite
Štai kaip dabar turėtų atrodyti kodas:
importuoti pygame iš pygame.locals importuoti * rezoliuciją = (400, 300) balta = (255, 255, 255) juoda = (0, 0, 0) raudona = (255, 0, 0) ekraną = pygame.display.set_mode (rezoliucija) klasės kamuolys: def _init _ (self, xPos = rezoliucija [0] / 2, yPos = rezoliucija [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 (self, surface): pygame.draw.circle (paviršius, juodas, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = rezoliucija [0]): self.dx *= -1, jei (self.y <= 0 arba self.y> = rezoliucija [1]): self.dy *= -1 kamuolys = Ball () laikrodis = pygame.time. Clock (), o True: ekranas. užpildyti (baltas) kamuolys.piešti (ekranas) kamuolys.atnaujinti () pygame.display.flip () laikrodis. varnelė (60), skirta įvykiui pygame.event.get (): if event.type == QUIT: pygame.quit ()
4 dalis iš 8: Žaidimo organizavimas
Žingsnis 1. Naudokite klases, kad viską sutvarkytumėte
Žaidimas bus sudėtingesnis. Naudokite objektinius metodus, kad sutvarkytumėte savo kodą.
Žingsnis 2. Padarykite žaidimo kilpą į klasę
Kadangi mūsų žaidime dabar yra duomenų, įskaitant jūsų žaidimo objektus ir funkcijas, prasminga savo žaidimų ciklą paversti klase.
klasės žaidimas ():
Žingsnis 3. Pridėkite konstruktorių
Čia parodysite kai kuriuos žaidimo objektus, sukursite mūsų ekraną ir laikrodį ir inicijuosite „Pygame“. Norint naudoti tam tikras funkcijas, pvz., Tekstą ar garsą, „Pygame“reikia inicijuoti.
klasės žaidimas (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (rezoliucija) self.clock = pygame.time. Clock ()
Žingsnis 4. Funkcijos įvykių tvarkymas
klasės žaidimas ():… def rankena
Žingsnis 5. Padarykite žaidimo kilpą funkcija
Įvykių tvarkymo funkciją iškvieskite kiekvieną kartą.
klasės žaidimas ():… def run (self): nors True: self.handleEvents () self.screen.fill (balta) self.clock.tick (60) pygame.display.flip ()
Žingsnis 6. Tvarkykite kelis žaidimo objektus
Šiuo metu šis kodas turi paraginti piešti ir atnaujinti mūsų objektą kiekviename kadre. Tai būtų netvarkinga, jei turėtumėte daug objektų. Pridėkime savo objektą prie masyvo, tada atnaujinsime ir piešime visus masyvo objektus kiekvienoje kilpoje. Dabar galite lengvai pridėti kitą objektą ir suteikti jam kitą pradinę padėtį.
klasės žaidimas (): def _init _ (self):… self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))… def run (self): o True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update () self.screen.fill (balta) žaidimuiObj in self.game Objektai: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip ()
Žingsnis 7. Išbandykite
Štai kaip dabar turėtų atrodyti kodas:
importuoti pygame iš pygame.locals importuoti * rezoliuciją = (400, 300) balta = (255, 255, 255) juoda = (0, 0, 0) raudona = (255, 0, 0) ekraną = pygame.display.set_mode (rezoliucija) klasės kamuolys: def _init _ (self, xPos = rezoliucija [0] / 2, yPos = rezoliucija [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 (self, surface): pygame.draw.circle (paviršius, juodas, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = rezoliucija [0]): self.dx *= -1, jei (self.y <= 0 arba self.y> = rezoliucija [1]): self.dy *= -1 klasės žaidimas (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (rezoliucija) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): renginiui pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvent s () žaidimuiObj „self.game“Objektai: gameObj.update () self.screen.fill (balta) žaidimuiObj in self.game Objektai: gameObj.draw (self.screen) self.clock.tick (60) pygame.display. flip () žaidimas (). run ()
5 dalis iš 8: Žaidėjo objekto pridėjimas
Žingsnis 1. Sukurkite žaidėjų klasę ir konstruktorių
Sukursite kitą ratą, kurį valdo pelė. Inicijuokite vertes konstruktoriuje. Spindulys yra vienintelė svarbi vertė.
klasės žaidėjas: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Žingsnis 2. Apibrėžkite, kaip nupiešti žaidėjo objektą
Tai bus tas pats, kaip nupiešėte kitus žaidimo objektus.
klasės žaidėjas:… def draw (aš, paviršius): pygame.draw.circle (paviršius, raudona, (self.x, self.y), self.radius)
Žingsnis 3. Pridėkite žaidėjo objekto pelės valdiklį
Kiekviename kadre patikrinkite pelės vietą ir nustatykite žaidėjų objektų vietą į tą tašką.
klasės grotuvas:… def atnaujinimas (savarankiškai): laidas = pygame.mouse.get_pos () self.x = laidas [0] self.y = laidas [1]
Žingsnis 4. Pridėkite žaidėjo objektą prie gameObjects
Sukurkite naują žaidėjo egzempliorių ir įtraukite jį į sąrašą.
klasės žaidimas (): def _init _ (self):… self.gameObjects.append (Player ())
Žingsnis 5. Išbandykite
Štai kaip dabar turėtų atrodyti kodas:
importuoti pygame iš pygame.locals importuoti * rezoliuciją = (400, 300) balta = (255, 255, 255) juoda = (0, 0, 0) raudona = (255, 0, 0) ekraną = pygame.display.set_mode (rezoliucija) klasės kamuolys: def _init _ (self, xPos = rezoliucija [0] / 2, yPos = rezoliucija [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 (self, surface): pygame.draw.circle (paviršius, juodas, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = rezoliucija [0]): self.dx *= -1, jei (self.y <= 0 arba self.y> = rezoliucija [1]): self.dy *= -1 klasės žaidėjas: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, surface): pygame.draw.circle (paviršius, raudona, (self.x, self.y), self.radius) def atnaujinimas (save): laidas = pygame.mouse.get_pos () self.x = laidas [0] self.y = kord [1] klasės žaidimas (): def _init _ (self): pygame.init () self.screen = pygame.display.set_ režimas (raiška) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))) def handleEvents (self): įvykis pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): o tiesa: self.handleEvents () žaidimuiObj savyje.gameObjects: gameObj.update () self.screen.fill (balta) žaidimuiObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). bėgti ()
6 dalis iš 8: Priversti objektus sąveikauti su grotuvu
Žingsnis 1. Pakeiskite atnaujinimo funkcijas
Kad objektai galėtų sąveikauti, jie turės turėti prieigą vienas prie kito. Pridėkime dar vieną parametrą prie atnaujinimo, kad jis būtų perduotas „gameObjects“sąraše. Turėsite jį pridėti prie žaidėjo ir kamuolio objektų. Jei turite daug žaidimo objektų, paveldėjimas gali padėti išlaikyti visus metodo parašus.
klasės kamuolys:… def atnaujinimas („self“, „gameObjects“):… klasės žaidėjas:… def atnaujinimas („self“, „gameObjects“):
Žingsnis 2. Patikrinkite žaidėjo ir kamuolių susidūrimus
Eikite per visus žaidimo objektus ir patikrinkite, ar objektų tipas yra kamuolys. Tada naudokite dviejų objektų spindulius ir atstumo formulę, kad patikrintumėte, ar jie nesusiduria. Apskritimus tikrai lengva patikrinti susidūrus. Tai yra didžiausia priežastis, kodėl šiam žaidimui nenaudojote kitos formos.
klasės žaidėjas:… def atnaujinimas („self“, „gameObjects“):… „gameObj“žaidime „Objektai“: jei gameObj.type == "kamuolys": jei (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2:
Žingsnis 3. Užbaikite žaidimą, jei žaidėjas gauna „smūgį“
Dabar tiesiog palikite žaidimą.
if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
Žingsnis 4. Išbandykite
Štai kaip dabar turėtų atrodyti kodas:
importuoti pygame iš pygame.locals importuoti * rezoliuciją = (400, 300) balta = (255, 255, 255) juoda = (0, 0, 0) raudona = (255, 0, 0) ekraną = pygame.display.set_mode (rezoliucija) klasės kamuolys: def _init _ (self, xPos = rezoliucija [0] / 2, yPos = rezoliucija [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 (self, surface): pygame.draw.circle (paviršius, juodas, (self.x, self.y), self.radius) def atnaujinimas (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 or self.x> = rezoliucija [0]): self.dx *= -1, jei (self.y <= 0 arba self.y> = rezoliucija [1]): self.dy *= -1 klasė Žaidėjas: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (aš, paviršius): pygame.draw.circle (paviršius, raudona, (self.x, self.y), self.radius) def atnaujinimas (self, gameObjects): kordas = pygame.mouse.get_pos () self.x = laidas [0] self.y = laidas [1] žaidimuiObj žaidimeObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () klasės žaidimas (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (rezoliucija) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ())) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): for event in 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 (balta) žaidimuiObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
7 dalis iš 8: žaidimų valdiklio pridėjimas kuriant objektus
Žingsnis 1. Sukurkite žaidimų valdiklio klasę
Žaidimo valdikliai yra atsakingi už žaidimo „paleidimą“. Tai skiriasi nuo mūsų žaidimų klasės, kuri yra atsakinga už visų mūsų objektų piešimą ir atnaujinimą. Kontrolierius periodiškai pridės kitą rutulį prie ekrano, kad žaidimas būtų sunkesnis. Pridėkite konstruktorių ir inicijuokite kai kurias pagrindines vertes. Intervalas bus laikas, kol bus pridėtas kitas kamuolys.
klasė GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "žaidimo valdiklis"
Žingsnis 2. Pridėkite atnaujinimo funkciją
Tai patikrins, kiek laiko praėjo nuo kamuolio pridėjimo arba nuo žaidimo pradžios. Jei laikas yra ilgesnis už intervalą, nustatysite laiką ir pridėsite rutulį.
klasė GameController:… def atnaujinimas (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball ())
Žingsnis 3. Suteikite rutuliams atsitiktinį greitį
Turite naudoti atsitiktinius skaičius, kad žaidimas kiekvieną kartą būtų kitoks. Tačiau rutulių greitis dabar yra slankiojo kablelio skaičius, o ne sveikasis skaičius.
klasė GameController:… def atnaujinimas (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball (xVel = atsitiktinis ()*2, yVel = atsitiktinis ()*2))
Žingsnis 4. Ištaisykite piešimo funkciją
Piešimo funkcija nepriima plūdžių. Prieš ištraukdami rutulius, paverskime rutulio padėtį sveikais skaičiais.
klasės kamuolys:… def draw (aš, paviršius): pygame.draw.circle (paviršius, juodas, (int (self.x), int (self.y)), self.radius)
Žingsnis 5. Apibrėžkite žaidimo valdiklio traukimo būdą
Kadangi tai yra žaidimo objektas, pagrindinė kilpa bandys jį nupiešti. Turite apibrėžti lygiosios funkciją, kuri nieko nedaro, kad žaidimas nesugestų.
klasė GameController:… def draw (savarankiškas, ekranas): leidimas
Žingsnis 6. Pridėkite žaidimo valdiklį prie gameObjects ir pašalinkite 2 kamuoliukus
Žaidimas dabar turėtų kas penkias sekundes kamuoliuką.
klasės žaidimas (): def _init _ (self):… self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
Žingsnis 7. Išbandykite
Štai kaip dabar turėtų atrodyti kodas:
importuoti pygame iš atsitiktinio importo atsitiktinai iš pygame.locals importas * rezoliucija = (400, 300) balta = (255, 255, 255) juoda = (0, 0, 0) raudona = (255, 0, 0) ekranas = žaidimas. display.set_mode (rezoliucija) klasės kamuolys: def _init _ (self, xPos = rezoliucija [0] / 2, yPos = rezoliucija [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 (aš, paviršius): pygame.draw.circle (paviršius, juoda, (int (self. x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 arba self. x> = rezoliucija [0]): self.dx *= -1, jei (self.y <= 0 arba self.y> = rezoliucija [1]): self.dy *= -1 klasės Žaidėjas: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (aš, paviršius): pygame.draw.circle (paviršius, raudona, (self.x), self.y), self.radius) def atnaujinimas (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] žaidimui gameObj Objektai: jei gameObj.type == "kamuolys": jei (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius)* * 2: pygame.quit () klasės GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "žaidimo valdiklis "def atnaujinimas (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 = atsitiktinis ()*2)) def draw (self, screen): perduoti klasės žaidimą (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (rezoliucija) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) def handleEvents (self): renginiui pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): o tiesa: self.handleEvents () žaidimuiObj in self.gameObjects: gameObj.update (self.gameObjects) self.screen. užpildyti (balta) žaidimuiObj savyje.žaidimasO bjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). run ()
8 dalis iš 8: Rezultato pridėjimas ir žaidimas baigtas
Žingsnis 1. Pridėkite balą prie žaidimų valdiklio klasės
Sukurkite šrifto objektą ir balo kintamąjį. Piešite šriftą kiekviename kadre, kad būtų rodomas rezultatas, ir padidinsite kiekvieno atnaujinto kadro rezultatą.
klasė GameController: def _init _ (self, interval = 5):… self.score = 0 self.scoreText = pygame.font. Font (Nėra, 12) def atnaujinimas (self, gameObjects):… self.score += 1 def draw (savarankiškai, ekranas): screen.blit (self.scoreText.render (str (self.score), tiesa, juoda), (5, 5))
Žingsnis 2. Pakeiskite žaidimo pabaigą
Atsikratykime mesti rūkyti, kai žaidėjas aptinka susidūrimą. Vietoj to grotuve nustatysite kintamąjį, kurį žaidimas gali patikrinti. Kai nustatytas „gameOver“, nustokite atnaujinti objektus. Tai užšaldys viską savo vietoje, kad žaidėjas galėtų pamatyti, kas atsitiko, ir patikrinti savo rezultatą. Atminkite, kad objektai vis dar piešiami, tik neatnaujinami.
klasės žaidėjas: def _init _ (self, rad = 20):… self.gameOver = klaidingas def atnaujinimas (self, gameObjects):… žaidimuiObj žaidimeObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = Tikros klasės žaidimas (): def _init _ (self): … Self.gameOver = False def run (self): o tiesa: self.handleEvents () jei ne self.gameOver: žaidimuiObj in self.gameObjects: gameObj.update (self.gameObjects), jei gameObj.type == "player": self.gameOver = gameObj.gameOver
Žingsnis 3. Išbandykite
Štai kaip dabar turėtų atrodyti baigtas kodas:
importuoti pygame iš atsitiktinio importo atsitiktinai iš pygame.locals importas * rezoliucija = (400, 300) balta = (255, 255, 255) juoda = (0, 0, 0) raudona = (255, 0, 0) ekranas = pygame. display.set_mode (rezoliucija) klasės kamuolys: def _init _ (self, xPos = rezoliucija [0] / 2, yPos = rezoliucija [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 (aš, paviršius): pygame.draw.circle (paviršius, juoda, (int (self. x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 arba self. x> = rezoliucija [0]): self.dx *= -1, jei (self.y <= 0 arba self.y> = rezoliucija [1]): self.dy *= -1 klasės Žaidėjas: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" self.gameOver = False def draw (self, surface): pygame.draw.circle (paviršius, raudona), (self.x, self.y), self.radius) def atnaujinimas (self, gameObjects): kordas = pygame.mouse.get_pos () self.x = kord [0] self.y = kord [1] žaidimuiObj žaidimeObjects: jei gameObj.type == "kamuolys": jei (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 (Nėra, 12) def atnaujinimas (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 (self, screen)): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5)) klasės žaidimas (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (rezoliucija) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) self.gameOver = False def handleEvents (self): renginiui pygame.event.get (): jei ev ent.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () if not self.gameOver: for gameObj in self.gameObjects: gameObj.update (self.gameObjects) if gameObj. type == "player": self.gameOver = gameObj.gameOver self.screen.fill (balta) žaidimuiObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () žaidimas (). paleisti ()
