Ini adalah pengenalan kepada Pygame bagi orang yang sudah mengenali Python. Artikel ini akan mengajar anda langkah-langkah untuk membina permainan sederhana yang mempunyai pemain mengelak bola yang melantun.
Langkah-langkah
Bahagian 1 dari 8: Memasang Pygame
Langkah 1. Muat turun Pygame
Cari untuk platform anda dari
Langkah 2. Jalankan pemasang
Langkah 3. Sahkan bahawa pemasangan berfungsi
Buka terminal Python. Taip "pygame import." Sekiranya anda tidak melihat sebarang kesalahan, Pygame berjaya dipasang.
import pygame
Bahagian 2 dari 8: Menyiapkan Tetingkap Asas
Langkah 1. Buka fail baru
Langkah 2. Import Pygame
Pygame adalah perpustakaan yang menyediakan akses ke fungsi grafik. Sekiranya anda mahukan lebih banyak maklumat mengenai bagaimana fungsi ini berfungsi, anda boleh mencarinya di laman web Pygame.
import pygame dari pygame.locals import *
Langkah 3. Tetapkan resolusi tetingkap
Anda akan membuat pemboleh ubah global untuk resolusi skrin sehingga dapat dirujuk di beberapa bahagian permainan. Ia juga senang dicari di bahagian atas fail sehingga boleh diubah kemudian. Untuk projek lanjutan, meletakkan maklumat ini dalam fail yang berasingan akan menjadi idea yang lebih baik.
peleraian = (400, 300)
Langkah 4. Tentukan beberapa warna
Warna dalam permainan pyg adalah (RBGA yang berkisar antara 0 hingga 255. Nilai alpha (A) adalah pilihan tetapi warna lain (merah, biru, dan hijau adalah wajib).
putih = (255, 255, 255) hitam = (0, 0, 0) merah = (255, 0, 0)
Langkah 5. Permulaan skrin
Gunakan pemboleh ubah resolusi yang telah ditentukan sebelumnya.
screen = pygame.display.set_mode (resolusi)
Langkah 6. Buat gelung permainan
Ulangi tindakan tertentu di setiap bingkai permainan kami. Buat gelung yang akan selalu berulang untuk mengitar semua tindakan ini.
Walaupun Betul:
Langkah 7. Warnakan skrin
skrin. isi (putih)
Langkah 8. Paparkan skrin
Sekiranya anda menjalankan program, skrin akan menjadi putih dan kemudian program tersebut akan rosak. Ini kerana sistem operasi menghantar acara ke permainan dan permainan tidak melakukan apa-apa dengan mereka. Setelah permainan menerima terlalu banyak acara yang tidak ditangani, ia akan terhempas.
sambil Betul:… pygame.display.flip ()
Langkah 9. Mengendalikan acara
Dapatkan senarai semua peristiwa yang berlaku di setiap bingkai. Anda hanya akan mengambil berat tentang satu acara, acara berhenti. Ini berlaku apabila pengguna menutup tetingkap permainan. Ini juga akan mengelakkan program kita terhenti kerana terlalu banyak acara.
sementara Benar:… untuk acara di pygame.event.get (): if event.type == QUIT: pygame.quit ()
Langkah 10. Cubalah
Begini kodnya sekarang:
import pygame dari pygame.locals import * resolusi = (400, 300) putih = (255, 255, 255) hitam = (0, 0, 0) merah = (255, 0, 0) skrin = pygame.display.set_mode (resolusi) sementara True: screen.fill (putih) pygame.display.flip () untuk acara di pygame.event.get (): if event.type == QUIT: pygame.quit ()
Bahagian 3 dari 8: Membuat Objek Permainan
Langkah 1. Buat kelas dan konstruktor baru
Tetapkan semua sifat objek. Anda juga memberikan nilai lalai untuk semua sifat.
bola kelas: def _init _ (diri, xPos = resolusi [0] / 2, yPos = resolusi [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 = "bola"
Langkah 2. Tentukan cara melukis objek
Gunakan sifat-sifat yang ditentukan dalam konstruktor untuk menarik bola sebagai bulatan dan juga melintasi permukaan ke dalam fungsi untuk menarik objek. Permukaan akan menjadi objek layar yang dibuat menggunakan resolusi sebelumnya.
def draw (diri, permukaan): pygame.draw.circle (permukaan, hitam, (self.x, self.y), self.radius)
Langkah 3. Buat contoh kelas dan juga memberitahu gelung permainan untuk menarik bola di setiap gelung
bola = Bola () sementara Benar:… bola.draw (skrin)
Langkah 4. Buat objek bergerak
Buat fungsi yang akan mengemas kini kedudukan objek. Panggil fungsi ini di setiap gelung permainan.
kelas bola:… def update (diri): self.x + = self.dx self.y + = self.dy
Langkah 5. Hadkan kadar bingkai
Bola akan bergerak dengan sangat pantas kerana gelung permainan berjalan ratusan kali sesaat. Gunakan jam Pygame untuk menghadkan kadar bingkai hingga 60 fps.
clock = pygame.time. Clock () sementara True:… clock.tick (60)
Langkah 6. Simpan bola di skrin
Tambahkan cek dalam fungsi kemas kini untuk membalikkan arah bola jika menyentuh salah satu tepi layar.
kelas bola:… def update (diri):… if (self.x <= 0 atau self.x> = resolusi [0]): self.dx * = -1 if (self.y <= 0 atau self.y > = peleraian [1]): self.dy * = -1
Langkah 7. Cubalah
Begini kodnya sekarang:
import pygame dari pygame.locals import * resolusi = (400, 300) putih = (255, 255, 255) hitam = (0, 0, 0) merah = (255, 0, 0) skrin = pygame.display.set_mode (resolusi) bola Bola: def _init _ (diri, xPos = resolusi [0] / 2, yPos = resolusi [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, permukaan): pygame.draw.circle (permukaan, hitam, (self.x, self.y), self.radius) def update (self): self.x + = self.dx self.y + = self.dy if (self.x <= 0 atau self.x> = resolusi [0]): self.dx * = -1 if (self.y <= 0 atau self.y> = resolusi [1]): self.dy * = -1 bola = Bola () jam = pygame.time. Clock () sementara True: skrin. isi (putih) ball.draw (layar) ball.update () pygame.display.flip () clock.tick (60) untuk acara di pygame.event.get (): if event.type == QUIT: pygame.quit ()
Bahagian 4 dari 8: Menyusun Permainan
Langkah 1. Gunakan kelas untuk mengatur semuanya
Permainan akan menjadi lebih rumit. Gunakan teknik berorientasikan objek untuk mengatur kod anda.
Langkah 2. Jadikan gelung permainan menjadi kelas
Oleh kerana permainan kami sekarang mempunyai data termasuk objek dan fungsi permainan anda, masuk akal untuk mengubah gelung permainan anda menjadi kelas.
permainan kelas ():
Langkah 3. Tambahkan konstruktor
Di sini anda akan menunjukkan beberapa objek permainan, membuat skrin dan jam kami dan memulakan Pygame. Pygame perlu diinisialisasi untuk menggunakan ciri tertentu seperti teks atau suara.
permainan kelas (): def _init _ (diri): pygame.init () self.screen = pygame.display.set_mode (resolusi) self.clock = pygame.time. Clock ()
Langkah 4. Mengendalikan acara dalam fungsi
permainan kelas ():… def handleEvents (diri): untuk acara di pygame.event.get (): if event.type == QUIT: pygame.quit ()
Langkah 5. Jadikan gelung permainan berfungsi
Panggil fungsi pengendalian acara setiap gelung.
permainan kelas ():… def run (self): while True: self.handleEvents () self.screen.fill (white) self.clock.tick (60) pygame.display.flip ()
Langkah 6. Mengendalikan pelbagai objek permainan
Sekarang kod ini harus memanggil menarik dan mengemas kini objek kami pada setiap bingkai. Ini akan menjadi tidak kemas jika anda mempunyai banyak objek. Mari tambahkan objek kami ke array dan kemudian kemas kini dan lukiskan semua objek dalam array setiap gelung. Sekarang anda boleh menambahkan objek lain dengan mudah dan memberikannya kedudukan permulaan yang berbeza.
permainan kelas (): def _init _ (diri):… self.gameObjects = self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100))… def run (self): while True: self.handleEvents () untuk gameObj dalam self.gameObjects: gameObj.update () self.screen.fill (putih) untuk gameObj dalam self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.lip ()
Langkah 7. Cubalah
Begini kodnya sekarang:
import pygame dari pygame.locals import * resolusi = (400, 300) putih = (255, 255, 255) hitam = (0, 0, 0) merah = (255, 0, 0) skrin = pygame.display.set_mode (resolusi) bola Bola: def _init _ (diri, xPos = resolusi [0] / 2, yPos = resolusi [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, permukaan): pygame.draw.circle (permukaan, hitam, (self.x, self.y), self.radius) def update (self): self.x + = self.dx self.y + = self.dy if (self.x <= 0 atau self.x> = resolusi [0]): self.dx * = -1 if (self.y <= 0 atau self.y> = resolusi [1]): self.dy * = -1 permainan kelas (): def _init _ (diri): pygame.init () self.screen = pygame.display.set_mode (resolusi) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Bola ()) self.gameObjects.append (Bola (100)) def handleEvents (diri): untuk acara dalam pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvent s () untuk gameObj dalam self.gameObjects: gameObj.update () self.screen.fill (putih) untuk gameObj dalam self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display. permainan flip () (). jalankan ()
Bahagian 5 dari 8: Menambah Objek Pemain
Langkah 1. Buat kelas pemain dan konstruktor
Anda akan membuat lingkaran lain yang dikendalikan oleh tetikus. Memulakan nilai dalam konstruktor. Jejari adalah satu-satunya nilai penting.
Pemain kelas: def _init _ (diri, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Langkah 2. Tentukan cara melukis objek pemain
Ini akan menjadi cara yang sama anda menarik objek permainan yang lain.
Pemain kelas:… def draw (diri, permukaan): pygame.draw.circle (permukaan, merah, (self.x, self.y), self.radius)
Langkah 3. Tambahkan kawalan tetikus untuk objek pemain
Di setiap bingkai, periksa lokasi tetikus dan tetapkan lokasi objek pemain ke titik itu.
Pemain kelas:… kemas kini def (diri): kord = pygame.mouse.get_pos () self.x = kord [0] self.y = kord [1]
Langkah 4. Tambahkan objek pemain ke gameObjects
Buat contoh pemain baru dan tambahkan ke senarai.
permainan kelas (): def _init _ (diri):… self.gameObjects.append (Pemain ())
Langkah 5. Cubalah
Begini kodnya sekarang:
import pygame dari pygame.locals import * resolusi = (400, 300) putih = (255, 255, 255) hitam = (0, 0, 0) merah = (255, 0, 0) skrin = pygame.display.set_mode (resolusi) bola Bola: def _init _ (diri, xPos = resolusi [0] / 2, yPos = resolusi [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, permukaan): pygame.draw.circle (permukaan, hitam, (self.x, self.y), self.radius) def update (self): self.x + = self.dx self.y + = self.dy if (self.x <= 0 atau self.x> = resolusi [0]): self.dx * = -1 if (self.y <= 0 atau self.y> = resolusi [1]): self.dy * = -1 class Player: def _init _ (self, rad = 20): self.x = 0 diri.y = 0 self.radius = rad self.type = "player" def draw (self, permukaan): pygame.draw.circle (permukaan, merah, (self.x, self.y), self.radius) def update (diri): tali = pygame.mouse.get_pos () self.x = kord [0] self.y = kord [1] permainan kelas (): def _init _ (diri): pygame.init () self.screen = pygame. paparan.set_ mode (resolusi) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Player ()) self.gameObjects.append (Ball ()) self.gameObjects.append (Bola (100)) def handleEvents (diri): untuk acara di pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () untuk gameObj dalam diri.gameObjects: gameObj.update () self.screen.fill (putih) untuk gameObj dalam self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () game (). lari ()
Bahagian 6 dari 8: Membuat Objek Berinteraksi dengan Pemain
Langkah 1. Tukar fungsi Kemas kini
Agar objek dapat berinteraksi, objek perlu saling berhubung. Mari tambahkan parameter lain untuk Kemas kini untuk dimasukkan ke dalam senarai gameObjects. Anda mesti menambahkannya ke objek pemain dan objek Bola. Sekiranya anda mempunyai banyak objek permainan, warisan dapat membantu anda memastikan semua tandatangan kaedah anda tetap sama.
class Ball:… def update (self, gameObjects):… class Player:… def update (diri, gameObjects):
Langkah 2. Periksa perlanggaran antara pemain dan bola
Teliti semua objek permainan dan periksa apakah jenis objek adalah bola. Kemudian gunakan jari-jari dua objek dan formula jarak untuk memeriksa sama ada objek tersebut berlanggar. Lingkaran sangat mudah untuk memeriksa perlanggaran. Ini adalah alasan terbesar bahawa anda tidak menggunakan bentuk lain untuk permainan ini.
Pemain kelas:… kemas kini def (self, gameObjects):… untuk gameObj dalam gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2:
Langkah 3. Tamatkan permainan jika pemain mendapat "hit"
Mari berhenti dari permainan buat masa ini.
jika (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit ()
Langkah 4. Cubalah
Begini kodnya sekarang:
import pygame dari pygame.locals import * resolusi = (400, 300) putih = (255, 255, 255) hitam = (0, 0, 0) merah = (255, 0, 0) skrin = pygame.display.set_mode (resolusi) bola Bola: def _init _ (diri, xPos = resolusi [0] / 2, yPos = resolusi [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, permukaan): pygame.draw.circle (permukaan, hitam, (self.x, self.y), self.radius) kemas kini def (self, gameObjects): self.x + = self.dx self.y + = self.dy if (self.x <= 0 atau self.x> = resolusi [0]): diri.dx * = -1 if (self.y <= 0 atau self.y> = resolusi [1]): self.dy * = -1 class Pemain: def _init _ (diri, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (diri, permukaan): pygame.draw.circle (permukaan, merah, (self.x, self.y), self.radius) kemas kini def (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] untuk gameObj dalam gameObjects: if gameObj.type == "ball": jika (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: pygame.quit () permainan kelas (): def _init _ (diri): pygame.init () self.screen = pygame.display.set_mode (resolution) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (Pemain () self.gameObjects.append (Ball ()) self.gameObjects.append (Ball (100)) def handleEvents (self): untuk acara di pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () untuk gameObj dalam self.gameObjects: gameObj.update (self.gameObjects) self.screen.fill (putih) untuk gameObj dalam self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () permainan (). jalankan ()
Bahagian 7 dari 8: Menambah Pengawal Permainan untuk Membuat Objek
Langkah 1. Buat kelas pengawal permainan
Pengawal permainan bertanggungjawab untuk "menjalankan" permainan. Ia berbeza dengan kelas permainan kami yang bertanggungjawab melukis dan mengemas kini semua objek kami. Pengawal akan secara berkala menambahkan bola lain ke layar untuk menjadikan permainan lebih sukar. Tambahkan konstruktor dan mulakan beberapa nilai asas. Selang akan menjadi masa sebelum bola lain ditambahkan.
class GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "pengawal permainan"
Langkah 2. Tambahkan fungsi kemas kini
Ini akan memeriksa berapa lama masa berlalu sejak bola ditambahkan atau dari awal permainan. Sekiranya waktunya lebih daripada selang waktu, anda akan menetapkan semula waktunya dan menambah bola.
class GameController:… update def (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Bola ())
Langkah 3. Berikan bebola halaju secara rawak
Anda perlu menggunakan nombor rawak untuk menjadikan permainan berbeza setiap masa. Walau bagaimanapun, halaju bola kini menjadi nombor titik terapung dan bukan bilangan bulat.
class GameController:… update def (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Bola (xVel = rawak () * 2, yVel = rawak () * 2))
Langkah 4. Betulkan fungsi cabutan
Fungsi undian tidak akan menerima apungan. Mari kita ubah kedudukan bola menjadi bilangan bulat sebelum bola ditarik.
kelas Bola:… def draw (diri, permukaan): pygame.draw.circle (permukaan, hitam, (int (self.x), int (self.y)), self.radius)
Langkah 5. Tentukan kaedah seri untuk pengawal permainan
Oleh kerana ia adalah objek permainan, gelung utama akan cuba melukisnya. Anda perlu menentukan fungsi undian yang tidak melakukan apa-apa supaya permainan tidak rosak.
class GameController:… def draw (diri, skrin): lulus
Langkah 6. Tambahkan pengawal permainan ke gameObjects dan keluarkan 2 bola
Permainan sekarang harus menelurkan bola setiap lima saat.
permainan kelas (): def _init _ (diri):… self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Pemain ())
Langkah 7. Cubalah
Begini kodnya sekarang:
import pygame dari rawak import rawak dari pygame.locals import * resolusi = (400, 300) putih = (255, 255, 255) hitam = (0, 0, 0) merah = (255, 0, 0) skrin = pygame. display.set_mode (resolusi) kelas Bola: def _init _ (diri, xPos = resolusi [0] / 2, yPos = resolusi [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 (diri, permukaan): pygame.draw.circle (permukaan, hitam, (int (diri). x), int (self.y)), self.radius) def update (self, gameObjects): self.x + = self.dx self.y + = self.dy if (self.x <= 0 atau diri sendiri. x> = resolusi [0]): self.dx * = -1 if (self.y <= 0 atau self.y> = resolusi [1]): self.dy * = -1 class Pemain: def _init _ (diri, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw (diri, permukaan): pygame.draw.circle (permukaan, merah, (self.x, self.y), self.radius) kemas kini def (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = cord [1] untuk gameObj dalam permainan Objek: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) * * 2: pygame.quit () kelas GameController: def _init _ (self, interval = 5): self.inter = interval self.next = pygame.time.get_ticks () + (2 * 1000) self.type = "pengawal permainan "def update (self, gameObjects): if self.next <pygame.time.get_ticks (): self.next = pygame.time.get_ticks () + (self.inter * 1000) gameObjects.append (Bola (xVel = rawak () * 2, yVel = rawak () * 2)) def draw (diri, skrin): permainan kelas lulus (): def _init _ (diri): pygame.init () self.screen = pygame.display.set_mode (resolusi self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Pemain ()) def handleEvents (diri): untuk acara di pygame.event.get (): if event.type == QUIT: pygame.quit () def run (self): while True: self.handleEvents () untuk gameObj dalam self.gameObjects: gameObj.update (self.gameObjects) self.screen.lengkapkan (putih) untuk gameObj dalam diri.gameO bjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () permainan (). jalankan ()
Bahagian 8 dari 8: Menambah Skor dan Permainan Berakhir
Langkah 1. Tambahkan skor ke kelas pengawal permainan
Buat objek fon dan pemboleh ubah skor. Anda akan menarik fon di setiap bingkai untuk memaparkan skor dan meningkatkan skor setiap bingkai dalam kemas kini.
class GameController: def _init _ (self, interval = 5):… self.score = 0 self.scoreText = pygame.font. Font (Tiada, 12) kemas kini def (self, gameObjects):… self.score + = 1 draw def (diri, skrin): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5))
Langkah 2. Ubah suai bagaimana permainan berakhir
Mari kita berhenti ketika pemain mengesan perlanggaran. Sebaliknya anda akan menetapkan pemboleh ubah dalam pemain yang boleh diperiksa oleh permainan. Apabila gameOver diatur, berhenti mengemas kini objek. Ini akan membekukan semua yang ada sehingga pemain dapat melihat apa yang berlaku dan memeriksa skor mereka. Perhatikan bahawa objek masih dilukis, tidak diperbaharui.
Pemain kelas: def _init _ (diri, rad = 20):… self.gameOver = Kemas kini def palsu (diri, gameObjects):… untuk gameObj dalam gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = Permainan kelas benar (): def _init _ (diri): … Self.gameOver = False def run (self): while True: self.handleEvents () if not self.gameOver: for gameObj in self.gameObjects: gameObj.update (self.gameObjects) if gameObj.type == "pemain": self.gameOver = gameObj.gameOver
Langkah 3. Cubalah
Inilah kod siap seperti sekarang:
import pygame dari rawak import rawak dari pygame.locals import * resolusi = (400, 300) putih = (255, 255, 255) hitam = (0, 0, 0) merah = (255, 0, 0) skrin = pygame. display.set_mode (resolusi) kelas Bola: def _init _ (diri, xPos = resolusi [0] / 2, yPos = resolusi [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 (diri, permukaan): pygame.draw.circle (permukaan, hitam, (int (diri). x), int (self.y)), self.radius) def update (self, gameObjects): self.x + = self.dx self.y + = self.dy if (self.x <= 0 atau diri sendiri. x> = resolusi [0]): self.dx * = -1 if (self.y <= 0 atau self.y> = resolusi [1]): self.dy * = -1 class Pemain: def _init _ (diri, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" self.gameOver = Draw def salah (diri, permukaan): pygame.draw.circle (permukaan, merah, (self.x, self.y), self.radius) def update (self, gameObjects): cord = pygame.mouse.get_pos () self.x = cord [0] self.y = kabel [1] untuk gameObj dalam gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x) ** 2 + (gameObj.y - self.y) ** 2 <= (gameObj.radius + self.radius) ** 2: self.gameOver = GameController kelas benar: def _init _ (diri, selang = 5): self.inter = selang diri.next = pygame.time.get_ticks () + (2 * 1000) diri. type = "game controller" self.score = 0 self.scoreText = pygame.font. Font (Tiada, 12) kemas kini def (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 draw def (diri, skrin): screen.blit (self.scoreText.render (str (self.score), True, black), (5, 5)) permainan kelas (): def _init _ (diri): pygame.init () self.screen = pygame.display.set_mode (resolusi) self.clock = pygame.time. Clock () self.gameObjects = self.gameObjects.append (GameController ()) self.gameObjects.append (Player ()) self.gameOver = Salah def handleEvents (diri): untuk acara di pygame.event.get (): if 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) jika gameObj. type == "player": self.gameOver = gameObj.gameOver self.screen.fill (putih) untuk gameObj dalam self.gameObjects: gameObj.draw (self.screen) self.clock.tick (60) pygame.display.flip () permainan (). jalankan ()
