Pembaca seperti Anda membantu mendukung MUO. Saat Anda melakukan pembelian menggunakan tautan di situs kami, kami dapat memperoleh komisi afiliasi. Baca selengkapnya.

Pygame menyediakan beberapa fungsi bawaan untuk mendeteksi benturan antar objek game. Ini sangat berharga karena mengetahui dengan tepat kapan dan bagaimana objek bergerak tumpang tindih bisa menjadi tugas yang rumit.

Pelajari cara menambahkan fisika dasar dan tabrakan di game Anda menggunakan modul pygame.

Fungsi Deteksi Benturan Bawaan Pygame

Fungsi deteksi tabrakan bawaan yang paling dasar adalah spritecollide. Dibutuhkan sprite, sekelompok sprite, dan nilai boolean yang menunjukkan apakah sprite harus "mati" (dihapus) atau tidak saat bertabrakan. Fungsi ini mengembalikan daftar sprite yang bertabrakan. Berikut adalah contoh cara menggunakannya:

collided_sprite = pygame.sprite.spritecollide (sprite1, sprite_group, BENAR)

Fungsi deteksi tabrakan lain yang bermanfaat adalah groupcollide, yang mengambil dua grup sprite dan juga nilai boolean. Fungsi ini mengembalikan kamus dengan sprite yang bertabrakan sebagai kunci dan sprite yang bertabrakan dengannya sebagai nilainya. Berikut adalah contoh cara menggunakannya:

instagram viewer 

collision_dict = pygame.sprite.groupcollide (grup1, grup2, BENAR, BENAR)

Membuat Game Platformer Dasar Menggunakan Fungsi spritecollide

Untuk membuat game platformer dasar menggunakan Pygame, Anda perlu membuat sprite pemain yang dapat dikontrol pengguna dan sprite platform untuk pemain berdiri. Anda dapat menggunakan fungsi spritecollide untuk mendeteksi saat sprite pemain bertabrakan dengan sprite platform dan mencegah pemain terjatuh dari platform.

Untuk memulai, instal modul pygame menggunakan pip:

pip instal pygame

Setelah itu, membuat kelas sederhana untuk Pemain dan Platform, keduanya harus mewarisi dari kelas Sprite Pygame. Kelas Pemain harus memiliki metode pembaruan untuk menangani posisi pemain berdasarkan kecepatan. Juga, itu harus memiliki variabel y_velocity untuk menerapkan efek gravitasi. Kelas Platform harus memiliki metode __init__ yang mengambil koordinat platform dan membuat permukaan dengan ukuran tersebut.

Kelas Pemain

Anda dapat membuat kelas Player menggunakan pygame.sprite. Modul Sprite. Kelas ini akan menginisialisasi pemain dengan koordinat x dan y yang diberikan. Kemudian, metode update akan memperbarui posisi pemain dengan menaikkan nilai y_velocity.

impor pygame
kelasPemain(pygame.sprite. Sprite):
def__init__(diri, x, y):
 super().__init__()
 self.image = pygame. Permukaan((32, 32))
 self.rect = self.image.get_rect (kiri atas=(x, y))
 self.y_velocity = 0
defmemperbarui(diri sendiri):
 self.rect.y += self.y_velocity

Kelas Platform

Kelas Platform juga menggunakan pygame.sprite. Modul Sprite. Kelas ini akan menginisialisasi platform dengan koordinat x dan y yang diberikan, serta lebar dan tinggi.

kelasPlatform(pygame.sprite. Sprite):
def__init__(diri, x, y, lebar, tinggi):
 super().__init__()
 self.image = pygame. Permukaan((lebar, tinggi))
 self.rect = self.image.get_rect (kiri atas=(x, y))

Putaran Permainan

Game loop akan memungkinkan Anda membuat jendela dengan ukuran 640x480. Kemudian, itu akan menjalankan loop yang akan memeriksa setiap kejadian, seperti perintah keluar. Itu juga akan memeriksa setiap tabrakan antara pemain dan platform. Terakhir, ini akan mengisi layar dengan warna putih, menggambar pemain dan platform, lalu membalik layar.

pemain = Pemain(100, 300)
grup_pemain = pygame.sprite. Kelompok()
player_group.add (pemain)
platform = Platform(50, 400, 100, 20)
platform_group = pygame.sprite. Kelompok()
platform_group.add (platform)


# Inisialisasi pygame dan buat jendela
pygame.init()
layar = pygame.display.set_mode((640, 480))


# Lingkaran permainan utama
berlari = BENAR


ketika berlari:
untuk peristiwa di dalam pygame.event.get():
jika event.type == pygame. BERHENTI:
 berlari = PALSU

 player_group.update()
 bertabrakan = pygame.sprite.spritecollide (pemain, grup_platform, PALSU)


jika bertabrakan:
 pemain.y_velocity = 0
 layar.isi((255, 255, 255))
 player_group.draw (layar)
 platform_group.draw (layar)
 pygame.display.flip()
pygame.berhenti()

Di bawah ini adalah outputnya:

Menerapkan Gravitasi dan Perilaku Melompat

Untuk menerapkan gravitasi dan perilaku melompat dalam game platformer Anda, Anda perlu menambahkan kecepatan y ke sprite pemain Anda dan memperbarui posisinya di setiap frame. Untuk melakukannya, Anda dapat menggunakan metode update di dalam kelas Player dan menambahkan potongan kode berikut:

kelasPemain(pygame.sprite. Sprite):
def__init__(diri, x, y):
 super().__init__()
 self.image = pygame. Permukaan((32, 32))
 self.rect = self.image.get_rect (kiri atas=(x, y))
 self.y_velocity = 0
defmemperbarui(diri sendiri):
 self.rect.y += self.y_velocity
 self.y_velocity += GRAVITASI # Terapkan gravitasi ke kecepatan y

Sekarang setiap kali Anda memanggil metode pembaruan, itu akan memperbarui posisi pemain sesuai dengan kecepatan dan gravitasinya.

Untuk membuat sprite pemain melompat, Anda dapat mengikat aksi melompat ke kunci atau tombol tertentu dan memperbarui kecepatan y pemain dengan nilai negatif. Cuplikan kode berikut adalah contoh cara melompat saat pemain menekan bilah spasi.

KECEPATAN_JUMP = -10
# di dalam lingkaran permainan
jika event.type == pygame. KEYDOWN Dan event.key == pygame. K_SPACE:
 player.y_velocity = JUMP_VELOCITY

Perhatikan bahwa Anda perlu memeriksa event.type untuk memastikan bahwa acara tersebut adalah acara KEYDOWN sebelum memeriksa nilai kunci.

Menambahkan Fisika Dasar Seperti Gesekan dan Percepatan

Untuk menambahkan fisika dasar seperti gesekan dan akselerasi ke game platform Anda, Anda perlu memperbarui kecepatan x sprite pemain Anda di setiap frame. Anda dapat menambahkan kecepatan x ke kelas pemain dan memperbaruinya dengan cara yang sama seperti kecepatan y. Untuk mengimplementasikan gesekan, Anda dapat mengurangi kecepatan x sprite pemain dengan jumlah kecil di setiap frame. Misalnya, Anda dapat menambahkan potongan kode berikut di dalam metode pembaruan kelas Pemain:

GESEK = 0.9
kelasPemain(pygame.sprite. Sprite):
def__init__(diri, x, y):
 super().__init__()
 self.image = pygame. Permukaan((32, 32))
 self.rect = self.image.get_rect (kiri atas=(x, y))
 self.y_velocity = 0
 self.x_velocity = 0
defmemperbarui(diri sendiri):
 self.rect.y += self.y_velocity
 self.rect.x += self.x_velocity
 self.y_velocity += GRAVITASI # Terapkan gravitasi ke kecepatan y
 self.x_velocity *= GESEK # Terapkan gesekan ke kecepatan x

Untuk mengimplementasikan akselerasi, Anda dapat menetapkan variabel, gerakan_pemain, untuk gerakan horizontal, dan memperbarui kecepatan x sprite pemain sesuai dengan nilai gerakan_pemain. Anda dapat melakukan ini dengan mengikat gerakan ke kunci atau tombol tertentu dan memperbarui kecepatan x pemain di putaran acara, misalnya:

PERCEPATAN = 0.5
pemain_gerakan = 0
jika event.type == pygame. TURUNKAN:
jika event.key == pygame. K_LEFT:
 pemain_gerakan = -1
elif event.key == pygame. K_KANAN:
 pemain_gerakan = 1
elif event.type == pygame. KEMBALIKAN:
jika acara.kunci di dalam (pygame. K_LEFT, pygame. K_KANAN):
 pemain_gerakan = 0

player.x_velocity += player_movement * ACCELERATION

Dengan menggunakan teknik ini, Anda dapat membuat game platformer yang sederhana namun menyenangkan menggunakan fungsi deteksi tabrakan bawaan dan fisika dasar Pygame. Dengan sedikit kreativitas dan eksperimen, Anda dapat menggunakan teknik ini untuk membuat berbagai permainan dan mekanisme permainan yang berbeda.

Anda dapat menemukan kode lengkap di repositori GitHub.

Di bawah ini adalah outputnya:

Tingkatkan Keterlibatan Pengguna Dengan Tabrakan

Banyak game memerlukan beberapa bentuk deteksi tabrakan. Anda dapat menggunakan tabrakan untuk membuat berbagai mekanisme permainan, mulai dari platformer sederhana hingga simulasi berbasis fisika yang kompleks.

Menerapkan fisika dasar seperti gravitasi, gesekan, dan akselerasi juga dapat sangat meningkatkan keterlibatan pengguna, menambah realisme dan kesan berat pada objek game.