Šis ir ievads Pygame cilvēkiem, kuri jau zina Python. Šis raksts iemācīs jums vienkāršas spēles izveidi, kurā spēlētājs izvairās no atlecošajām bumbiņām.
Soļi
1. daļa no 8: Pygame instalēšana
Solis 1. Lejupielādējiet Pygame
Atrodiet to savai platformai vietnē
2. solis. Palaidiet instalētāju
3. solis. Pārbaudiet, vai instalācija darbojās
Atveriet Python termināli. Ierakstiet “importēt spēles”. Ja neredzat kļūdas, Pygame tika veiksmīgi instalēts.
importēt pigame
2. daļa no 8: Pamata loga iestatīšana
1. solis. Atveriet jaunu failu
2. darbība. Importējiet Pygame
Pygame ir bibliotēka, kas nodrošina piekļuvi grafikas funkcijām. Ja vēlaties iegūt vairāk informācijas par to, kā šīs funkcijas darbojas, varat tās meklēt vietnē Pygame.
importēt pygame no pygame.locals importēt *
3. solis. Iestatiet loga izšķirtspēju
Jūs izveidosit globālu mainīgo ekrāna izšķirtspējai, lai uz to varētu atsaukties vairākās spēles daļās. To ir arī viegli atrast faila augšdaļā, lai to vēlāk varētu mainīt. Uzlabotiem projektiem šīs informācijas ievietošana atsevišķā failā būtu labāka ideja.
izšķirtspēja = (400, 300)
4. solis. Definējiet dažas krāsas
Krāsas spēlē ir (RBGA, kuras vērtības svārstās no 0 līdz 255. Alfa vērtība (A) nav obligāta, bet citas krāsas (sarkana, zila un zaļa) ir obligātas).
balta = (255, 255, 255) melna = (0, 0, 0) sarkana = (255, 0, 0)
5. solis. Inicializējiet ekrānu
Izmantojiet iepriekš definēto izšķirtspējas mainīgo.
ekrāns = pygame.display.set_mode (izšķirtspēja)
6. solis. Izveidojiet spēles cilpu
Atkārtojiet noteiktas darbības visos mūsu spēles kadros. Izveidojiet cilpu, kas vienmēr atkārtosies, lai veiktu visas šīs darbības.
kamēr taisnība:
7. solis. Krāsojiet ekrānu
screen.fill (balts)
8. solis. Parādiet ekrānu
Palaižot programmu, ekrāns kļūs balts un pēc tam programma avarēs. Tas ir tāpēc, ka operētājsistēma sūta notikumus uz spēli, un spēle ar tiem neko nedara. Tiklīdz spēle saņems pārāk daudz neapstrādātu notikumu, tā avarēs.
kamēr taisnība:… pygame.display.flip ()
9. solis. Rīkojieties ar notikumiem
Iegūstiet sarakstu ar visiem notikumiem, kas notikuši katrā kadrā. Jums rūp tikai viens notikums - izstāšanās notikums. Tas notiek, kad lietotājs aizver spēles logu. Tas arī novērsīs mūsu programmas sabrukumu pārāk daudzu notikumu dēļ.
kamēr True:… notikumam pygame.event.get (): if event.type == QUIT: pygame.quit ()
10. solis. Izmēģiniet to
Lūk, kā kodam vajadzētu izskatīties tagad:
importēt pygame no pygame.locals importēt * izšķirtspēja = (400, 300) balta = (255, 255, 255) melna = (0, 0, 0) sarkana = (255, 0, 0) ekrāns = pygame.display.set_mode (izšķirtspēja), kamēr True: screen.fill (balta) pygame.display.flip () notikumam pygame.event.get (): if event.type == QUIT: pygame.quit ()
3. daļa no 8: Spēles objekta izveide
1. solis. Izveidojiet jaunu klasi un konstruktoru
Iestatiet visas objekta īpašības. Jūs arī sniedzat noklusējuma vērtības visiem īpašumiem.
klases bumba: def _init _ (self, xPos = izšķirtspēja [0] / 2, yPos = izšķirtspēja [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 = "bumba"
2. solis. Definējiet, kā uzzīmēt objektu
Izmantojiet konstruktorā noteiktās īpašības, lai uzzīmētu bumbu kā apli, kā arī nodotu virsmu objekta vilkšanas funkcijai. Virsma būs ekrāna objekts, kas tika izveidots, izmantojot iepriekšējo izšķirtspēju.
def draw (sevis, virsmas): pygame.draw.circle (virsma, melna, (self.x, self.y), self.radius)
3. solis. Izveidojiet klases eksemplāru, kā arī pasakiet spēles cilpai, lai tā ievelk bumbu katrā cilpā
bumba = bumba (), kamēr taisnība:… ball.draw (ekrāns)
4. solis. Pārvietojiet objektu
Izveidojiet funkciju, kas atjauninās objekta atrašanās vietu. Izsauciet šo funkciju katrā spēles ciklā.
klases bumba:… def update (self): self.x += self.dx self.y += self.dy
5. solis. Ierobežojiet kadru ātrumu
Bumba kustēsies ļoti ātri, jo spēles cilpa darbojas simtiem reižu sekundē. Izmantojiet Pygame pulksteni, lai ierobežotu kadru ātrumu līdz 60 kadriem sekundē.
pulkstenis = pygame.time. Clock (), kamēr True:… clock.tick (60)
6. Turiet bumbu uz ekrāna
Atjaunināšanas funkcijā pievienojiet čekus, lai mainītu bumbiņas virzienu, ja tā trāpa vienā no ekrāna malām.
klases bumba:… def update (self):… if (self.x <= 0 or self.x> = resolution [0]): self.dx *= -1 if (self.y <= 0 or self.y > = izšķirtspēja [1]): self.dy *= -1
7. solis. Izmēģiniet to
Lūk, kā kodam vajadzētu izskatīties tagad:
importēt pygame no pygame.locals importēt * izšķirtspēja = (400, 300) balta = (255, 255, 255) melna = (0, 0, 0) sarkana = (255, 0, 0) ekrāns = pygame.display.set_mode (izšķirtspēja) klases bumba: def _init _ (self, xPos = izšķirtspēja [0] / 2, yPos = izšķirtspēja [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 (virsma, melna, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 vai self.x> = izšķirtspēja [0]): self.dx *= -1, ja (self.y <= 0 vai self.y> = izšķirtspēja [1]): self.dy *= -1 bumba = Ball () pulkstenis = pygame.time. Clock (), kamēr True: screen. aizpildīt (balta) ball.draw (screen) ball.update () pygame.display.flip () clock.tick (60) notikumam pygame.event.get (): if event.type == QUIT: pygame.quit ()
4. daļa no 8: Spēles organizēšana
1. solis. Izmantojiet nodarbības, lai visu sakārtotu
Spēle kļūs sarežģītāka. Izmantojiet uz objektu orientētas metodes, lai sakārtotu kodu.
Solis 2. Padariet spēles cilpu klasē
Tā kā mūsu spēlē tagad ir dati, tostarp jūsu spēles objekti un funkcijas, ir jēga pārvērst savu spēļu cilpu par klasi.
klases spēle ():
3. solis. Pievienojiet konstruktoru
Šeit jūs parādīsit dažus spēles objektus, izveidosit mūsu ekrānu un pulksteni un inicializēsiet Pygame. Pygame ir jāinicializē, lai izmantotu noteiktas funkcijas, piemēram, tekstu vai skaņu.
klases spēle (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (izšķirtspēja) self.clock = pygame.time. Clock ()
4. solis. Apstrādājiet notikumus kādā funkcijā
klases spēle ():… def handleEvents (self): notikumam pygame.event.get (): if event.type == QUIT: pygame.quit ()
Solis 5. Padariet spēles cilpu par funkciju
Izsauciet notikumu apstrādes funkciju katrā ciklā.
klases spēle ():… def run (self): kamēr True: self.handleEvents () self.screen.fill (balta) self.clock.tick (60) pygame.display.flip ()
6. Darbs ar vairākiem spēles objektiem
Šobrīd šim kodam katrā kadrā ir jāizsauc zīmēt un atjaunināt mūsu objektā. Tas būtu netīrs, ja jums būtu daudz priekšmetu. Pievienosim savu objektu masīvam un pēc tam katru cilpu atjaunināsim un uzzīmēsim visus masīva objektus. Tagad jūs varat viegli pievienot citu objektu un piešķirt tam citu sākuma pozīciju.
klases spēle (): def _init _ (self):… self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))… def run (self): kamēr True: self.handleEvents () gameObj in self.gameObjects: gameObj.update () self.screen.fill (balts) spēleiObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip ()
7. solis. Izmēģiniet to
Lūk, kā kodam vajadzētu izskatīties tagad:
importēt pygame no pygame.locals importēt * izšķirtspēja = (400, 300) balta = (255, 255, 255) melna = (0, 0, 0) sarkana = (255, 0, 0) ekrāns = pygame.display.set_mode (izšķirtspēja) klases bumba: def _init _ (self, xPos = izšķirtspēja [0] / 2, yPos = izšķirtspēja [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 (virsma, melna, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 vai self.x> = izšķirtspēja [0]): self.dx *= -1, ja (self.y <= 0 vai self.y> = izšķirtspēja [1]): self.dy *= -1 klases spēle (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (izšķirtspēja) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): notikumam pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): kamēr True: self.handleEvent s () spēleiObj self.gameObjects: gameObj.update () self.screen.fill (balts) spēleiObj self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display. flip () spēle (). run ()
5. daļa no 8: Spēlētāja objekta pievienošana
1. solis. Izveidojiet spēlētāju klasi un konstruktoru
Jūs izveidosit vēl vienu loku, kuru kontrolē pele. Inicializējiet vērtības konstruktorā. Rādiuss ir vienīgā svarīgā vērtība.
klases spēlētājs: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
2. solis. Definējiet, kā uzzīmēt spēlētāja objektu
Tas būs tāds pats kā jūs uzzīmējāt citus spēles objektus.
klases spēlētājs:… def draw (sevis, virsmas): pygame.draw.circle (virsma, sarkana, (self.x, self.y), self.radius)
Solis 3. Pievienojiet atskaņotāja objektam peles vadīklu
Katrā kadrā pārbaudiet peles atrašanās vietu un iestatiet spēlētāju objektu atrašanās vietu uz šo punktu.
klases spēlētājs:… def update (self): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1]
4. solis. Pievienojiet atskaņotāja objektu gameObjects
Izveidojiet jaunu spēlētāja instanci un pievienojiet to sarakstam.
klases spēle (): def _init _ (self):… self.gameObjects.append (Player ())
5. solis. Izmēģiniet to
Lūk, kā kodam vajadzētu izskatīties tagad:
importēt pygame no pygame.locals importēt * izšķirtspēja = (400, 300) balta = (255, 255, 255) melna = (0, 0, 0) sarkana = (255, 0, 0) ekrāns = pygame.display.set_mode (izšķirtspēja) klases bumba: def _init _ (self, xPos = izšķirtspēja [0] / 2, yPos = izšķirtspēja [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 (virsma, melna, (self.x, self.y), self.radius) def update (self): self.x += self.dx self.y += self.dy if (self.x <= 0 vai self.x> = izšķirtspēja [0]): self.dx *= -1, ja (self.y <= 0 vai self.y> = izšķirtspēja [1]): self.dy *= -1 klases spēlētājs: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, virsmas): pygame.draw.circle (virsma, sarkana, (self.x, self.y), self.radius) def update (self): aukla = pygame.mouse.get_pos () self.x = aukla [0] self.y = aukla [1] klases spēle (): def _init _ (self): pygame.init () self.screen = pygame.display.set_ režīms (izšķirtspēja) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): notikumam pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): kamēr True: self.handleEvents () gameObj in self.gameObjects: gameObj.update () self.screen.fill (balta) spēleiObj self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () spēle (). palaist ()
6. daļa no 8: Objektu mijiedarbības nodrošināšana ar atskaņotāju
1. darbība. Mainiet atjaunināšanas funkcijas
Lai objekti varētu mijiedarboties, tiem jābūt pieejamiem viens otram. Pievienosim atjauninājumam vēl vienu parametru, lai to nodotu gameObjects sarakstam. Jums tas būs jāpievieno gan spēlētāja objektam, gan bumbas objektiem. Ja jums ir daudz spēļu objektu, mantošana varētu palīdzēt saglabāt visus metodes parakstus vienādus.
klases bumba:… def atjauninājums (self, gameObjects):… klases spēlētājs:… def update (self, gameObjects):
2. solis. Pārbaudiet, vai nav sadursmes starp spēlētāju un bumbiņām
Iet cauri visiem spēles objektiem un pārbaudiet, vai objektu veids ir bumba. Pēc tam izmantojiet abu objektu rādiusus un attāluma formulu, lai pārbaudītu, vai tie saduras. Lokus patiešām ir viegli pārbaudīt sadursmēs. Tas ir lielākais iemesls, kāpēc šai spēlei neizmantojāt kādu citu formu.
klases spēlētājs:… def atjauninājums (self, gameObjects):… gameObj spēlēObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2:
Solis 3. Pārtrauciet spēli, ja spēlētājs saņem "sitienu"
Pagaidām vienkārši iziesim no spēles.
if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
4. solis. Izmēģiniet to
Lūk, kā kodam vajadzētu izskatīties tagad:
importēt pygame no pygame.locals importēt * izšķirtspēja = (400, 300) balta = (255, 255, 255) melna = (0, 0, 0) sarkana = (255, 0, 0) ekrāns = pygame.display.set_mode (izšķirtspēja) klases bumba: def _init _ (self, xPos = izšķirtspēja [0] / 2, yPos = izšķirtspēja [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 (virsma, melna, (self.x, self.y), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 vai self.x> = izšķirtspēja [0]): self.dx *= -1, ja (self.y <= 0 vai self.y> = izšķirtspēja [1]): self.dy *= -1 klase Spēlētājs: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, virsmas): pygame.draw.circle (virsma, sarkana, (self.x, self.y), self.radius) def atjauninājums (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () klases spēle (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (izšķirtspēja) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): notikumam 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 (balts) spēleiObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () spēle (). run ()
7. daļa no 8: Spēļu kontroliera pievienošana objektu izveidei
Solis 1. Izveidojiet spēļu kontroliera klasi
Spēles kontrolieri ir atbildīgi par spēles "vadīšanu". Tas atšķiras no mūsu spēļu klases, kas ir atbildīga par visu mūsu objektu zīmēšanu un atjaunināšanu. Kontrolieris periodiski pievienos ekrānam vēl vienu bumbiņu, lai padarītu spēli grūtāku. Pievienojiet konstruktoru un inicializējiet dažas pamatvērtības. Intervāls būs laiks, pirms tiek pievienota cita bumba.
klases GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "spēles kontrolieris"
2. solis. Pievienojiet atjaunināšanas funkciju
Tas pārbaudīs, cik daudz laika ir pagājis kopš bumbas pievienošanas brīža vai no spēles sākuma. Ja laiks pārsniedz intervālu, jūs atiestatīsit laiku un pievienosit bumbiņu.
klases GameController:… def update (self, gameObjects): ja self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball ())
3. Piešķiriet bumbiņām izlases ātrumu
Lai spēle būtu atšķirīga, jums katru reizi jāizmanto nejauši skaitļi. Tomēr bumbiņu ātrums tagad ir peldošā komata skaitlis, nevis vesels skaitlis.
klases GameController:… def update (self, gameObjects): ja self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball (xVel = nejaušs ()*2, yVel = nejaušs ()*2))
Solis 4. Labojiet zīmēšanas funkciju
Izlozes funkcija nepieņem pludiņus. Pirms bumbiņu izlozēšanas pārveidosim bumbas pozīciju veselos skaitļos.
klases bumba:… def draw (self, surface): pygame.draw.circle (virsma, melna, (int (self.x), int (self.y)), self.radius)
5. solis. Definējiet spēles kontroliera izlozes metodi
Tā kā tas ir spēles objekts, galvenā cilpa mēģinās to uzzīmēt. Jums būs jādefinē izlozes funkcija, kas neko nedara, lai spēle netiktu avarēta.
klases GameController:… def draw (self, screen): piespēle
6. solis. Pievienojiet spēles kontrolieri gameObjects un noņemiet 2 bumbiņas
Spēlei tagad ik pēc piecām sekundēm vajadzētu radīt bumbu.
klases spēle (): def _init _ (self):… self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ())
7. solis. Izmēģiniet to
Lūk, kā kodam vajadzētu izskatīties tagad:
importēt pygame no nejaušas importēšanas izlases veidā no pygame. display.set_mode (izšķirtspēja) klases bumba: def _init _ (self, xPos = izšķirtspēja [0] / 2, yPos = izšķirtspēja [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, virsmas): pygame.draw.circle (virsma, melna, (int (self. x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 vai self. x> = izšķirtspēja [0]): self.dx *= -1, ja (self.y <= 0 vai self.y> = izšķirtspēja [1]): self.dy *= -1 klases Spēlētājs: def _init _ (self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (self, surface): pygame.draw.circle (virsma, sarkana, (self.x, self.y), self.radius) def update (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] spēleiObj spēlē Objekti: ja gameObj.type == "bumba": ja (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius)* * 2: pygame.quit () klases GameController: def _init _ (self, interval = 5): self.inter = intervāls self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "spēles kontrolieris "def update (self, gameObjects): ja self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Ball (xVel = random) ()*2, yVel = nejauši ()*2)) def draw (self, screen): iziet klases spēli (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (izšķirtspēja) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) def handleEvents (self): notikumam pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): kamēr True: self.handleEvents () for gameObj in self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (balts) spēleiObj sevī.gameO bjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () spēle (). run ()
8. daļa no 8: Rezultāta pievienošana un spēles beigas
1. solis. Pievienojiet punktu skaitu spēļu kontrolieru klasei
Izveidojiet fonta objektu un punktu mainīgo. Jūs uzzīmēsiet fontu katrā kadrā, lai parādītu rezultātu, un palielinātu katra atjauninājuma kadra rezultātu.
klases GameController: def _init _ (self, interval = 5):… self.score = 0 self.scoreText = pygame.font. Font (nav, 12) def update (self, gameObjects):… self.score += 1 def neizšķirts (self, screen): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5))
2. solis. Mainiet spēles beigu veidu
Atbrīvosimies no atmešanas, kad spēlētājs konstatēs sadursmi. Tā vietā jūs atskaņotājā iestatīsit mainīgo, kuru spēle var pārbaudīt. Kad ir iestatīts gameOver, pārtrauciet objektu atjaunināšanu. Tas iesaldēs visu savā vietā, lai spēlētājs varētu redzēt notikušo un pārbaudīt savu rezultātu. Ņemiet vērā, ka objekti joprojām tiek zīmēti, tikai netiek atjaunināti.
klases spēlētājs: def _init _ (self, rad = 20):… self.gameOver = Nepareizs def atjauninājums (self, gameObjects):… gameObj spēlēObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = Patiesas klases spēle (): def _init _ (self): … Self.gameOver = False def run (self): kamēr True: self.handleEvents () ja ne self.gameOver: gameObj in self.gameObjects: gameObj.update (self.gameObjects), ja gameObj.type == "player": self.gameOver = gameObj.gameOver
Solis 3. Izmēģiniet to
Gatavam kodam tagad vajadzētu izskatīties šādi:
importēt pygame no nejaušas importēšanas izlases veidā no pygame. display.set_mode (izšķirtspēja) klases bumba: def _init _ (self, xPos = izšķirtspēja [0] / 2, yPos = izšķirtspēja [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, virsmas): pygame.draw.circle (virsma, melna, (int (self. x), int (self.y)), self.radius) def update (self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 vai self. x> = izšķirtspēja [0]): self.dx *= -1, ja (self.y <= 0 vai self.y> = izšķirtspēja [1]): self.dy *= -1 klases Spēlētājs: 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 (virsma, sarkana, (self.x, self.y), self.radius) def update (self, gameObjects): aukla = pygame.mouse.get_pos () self.x = aukla [0] self.y = aukla [1] spēleiObj spēlēObjects: ja gameObj.type == "bumba": ja (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 = intervāls self.next = pygame.time.get_ticks () + (2*1000) self. type = "spēles kontrolieris" self.score = 0 self.scoreText = pygame.font. Font (Nav, 12) def atjauninājums (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter*1000) spēle): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5)) klases spēle (): def _init _ (self): pygame.init () self.screen = pygame.display.set_mode (izšķirtspēja) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) self.gameOver = False def handleEvents (self): notikumam pygame.event.get (): ja ev ent.type == QUIT: pygame.quit () def run (self): kamēr True: self.handleEvents () ja ne self.gameOver: gameObj in self.gameObjects: gameObj.update (self.gameObjects), ja gameObj. type == "player": self.gameOver = gameObj.gameOver self.screen.fill (balts) gameObj in self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () spēle (). palaist ()
