Jadikan game arcade Anda lebih menyenangkan dan mengasyikkan dengan menambahkan objek bergerak acak.

Objek bergerak acak dapat menghadirkan kegembiraan dan ketidakpastian pada game. Itu membuat mereka lebih menarik dan menantang bagi pemain. Pustaka Arcade Python menyediakan cara sederhana dan efisien untuk menggabungkan objek bergerak acak ke dalam gim Anda.

Buat Game Sederhana

Sebelum memulai, pastikan Anda sudah pip diinstal pada perangkat Anda. Gunakan perintah ini untuk menginstal arcade perpustakaan:

pip menginstal arcade

Setelah itu, buat jendela menggunakan arcade. Jendela class dan atur warna background menjadi putih.

Kode yang digunakan dalam artikel ini tersedia di sini repositori GitHub dan gratis untuk Anda gunakan di bawah lisensi MIT.

Atur posisi pemain ke tengah layar secara horizontal dan tambahkan sedikit jarak dari atas. Anda dapat mengontrol pergerakan pemain menggunakan tombol panah.

Berikut kode untuk permainan dasar kami:

impor arcade
SCREEN_WIDTH = 800
LAYAR_TINGGI = 600
PEMAIN_RADIUS = 15







instagram viewer



kelasMyGame(arcade. Jendela):
def__init__(diri, lebar, tinggi):
 super().__init__(lebar, tinggi)
 arcade.set_background_color (arcade.color. PUTIH)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


defon_draw(diri sendiri):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BIRU)


defmemperbarui(mandiri, waktu_delta):
lulus


defon_key_press(mandiri, kunci, pengubah):
jika kunci == arcade.kunci. KIRI:
 self.player_x -= 5
elif kunci == arcade.kunci. BENAR:
 self.player_x += 5
jika __nama__ == "__utama__":
 game = Permainan Saya (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.lari()

Menambahkan Banyak Objek

Untuk menambahkan objek bergerak acak ke game Anda, buat daftar untuk menyimpan posisi objek dan perbarui setiap frame. Anda juga bisa menggunakan sprite sebagai objek.

Dalam kode game Anda, tambahkan daftar bernama objek untuk menyimpan posisi objek bergerak acak. Setelah itu, hasilkan jumlah objek (NUM_BENDA) dengan koordinat x dan y acak dalam batas layar. Objek digambar sebagai lingkaran merah menggunakan arcade.draw_circle_filled fungsi.

impor arcade
impor acak
SCREEN_WIDTH = 800
LAYAR_TINGGI = 600
PEMAIN_RADIUS = 15
OBJEK_RADIUS = 10
NUM_BENDA = 10


kelasMyGame(arcade. Jendela):
def__init__(diri, lebar, tinggi):
 super().__init__(lebar, tinggi)
 arcade.set_background_color (arcade.color. PUTIH)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


 self.objek = []
untuk _ di dalam rentang (NUM_OBJECTS):
 x = acak.randint(0, SCREEN_WIDTH)
 y = acak.randint(0, SCREEN_HEIGHT)
 self.objects.append((x, y))


defon_draw(diri sendiri):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BIRU)


untuk obj di dalam diri.objek:
 x, y = objek
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. MERAH)


defmemperbarui(mandiri, waktu_delta):
lulus


defon_key_press(mandiri, kunci, pengubah):
jika kunci == arcade.kunci. KIRI:
 self.player_x -= 5
elif kunci == arcade.kunci. BENAR:
 self.player_x += 5
jika __nama__ == "__utama__":
 game = Permainan Saya (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.lari()

Di bawah ini adalah outputnya:

Menerapkan Algoritma Gerakan Acak

Untuk membuat objek bergerak secara acak, perbarui posisinya di memperbarui metode menggunakan algoritma gerakan acak.

Ulangi setiap objek dan hasilkan nilai acak untuk dx Dan dy, mewakili perubahan koordinat x dan y. Kemudian perbarui posisi objek dengan menambahkan nilai-nilai ini. Berikut kode yang dimodifikasi:

defmemperbarui(mandiri, waktu_delta):
untuk Saya di dalam rentang (NUM_OBJECTS):
 x, y = self.objek[i]
 dx = acak.randint(-5, 5)
 dy = acak.randint(-5, 5)
 x += dx
 y += dy
 self.objects[i] = (x, y)

Di bawah ini adalah outputnya:

Objek Bergerak Menuju Pemain

Untuk menambah lebih banyak interaksi, buat objek bergerak ke arah pemain. Anda dapat mencapainya dengan menghitung vektor arah antara objek dan pemutar dan menyesuaikan posisi objek.

Untuk ini, hitung selisih koordinat x dan y antara objek dan pemain. Dengan menormalkan nilai-nilai ini, Anda memperoleh vektor arah. Kemudian gandakan vektor ini dengan faktor kecepatan (dalam hal ini 3) dan tambahkan ke posisi objek. Berikut updatenya memperbarui metode:

defmemperbarui(mandiri, waktu_delta):
untuk Saya di dalam rentang (NUM_OBJECTS):
 x, y = self.objek[i]
 dx = self.player_x - x
 dy = self.player_y - y
 jarak = matematika.sqrt (dx ** 2 + di ** 2)
 dx /= jarak
 dy / = jarak
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Di bawah ini adalah outputnya:

Objek Mulai Bergerak Saat Pemain Memasuki Sekitarnya

Untuk menambahkan dinamika lebih lanjut, ubah kode sehingga objek mulai bergerak hanya saat pemain memasuki area sekitarnya. Tambahkan kode untuk gerakan pemain dan tentukan radius di mana objek menjadi aktif.

defmemperbarui(mandiri, waktu_delta):
untuk Saya di dalam rentang (NUM_OBJECTS):
 x, y = self.objek[i]
 dx = self.player_x - x
 dy = self.player_y - y
 jarak = matematika.sqrt (dx ** 2 + di ** 2)

jika jarak < 100: # Sesuaikan radius sesuai kebutuhan
 dx /= jarak
 dy / = jarak
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Deteksi Tabrakan dan Interaksi

Sekarang, tambahkan deteksi tabrakan antara pemain dan objek, dan tentukan perilaku saat terjadi tabrakan. Modifikasi memperbarui metode untuk menangani tabrakan:

defmemperbarui(mandiri, waktu_delta):
untuk Saya di dalam rentang (NUM_OBJECTS):
 x, y = self.objek[i]
 dx = self.player_x - x
 dy = self.player_y - y
 jarak = matematika.sqrt (dx ** 2 + di ** 2)

jika jarak < PLAYER_RADIUS + OBJECT_RADIUS:
# jika terjadi tabrakan, tangani di sini
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), acak.randint(0, SCREEN_HEIGHT)))

elif jarak < 100:
 dx /= jarak
 dy / = jarak
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Menyeimbangkan Keacakan

Untuk menciptakan pengalaman gameplay yang seimbang, penting untuk menyempurnakan gerakan acak dan pemijahan objek. Berikut adalah beberapa contoh bagaimana Anda dapat menyesuaikan kode untuk mencapai keseimbangan yang lebih baik dalam game Anda:

Membatasi Kecepatan Maksimum

Untuk mencegah objek bergerak terlalu cepat, Anda dapat memperkenalkan batas kecepatan maksimum. Modifikasi memperbarui metode untuk memasukkan batasan kecepatan:

defmemperbarui(mandiri, waktu_delta):
untuk Saya di dalam rentang (NUM_OBJECTS):
 x, y = self.objek[i]
 dx = self.player_x - x
 dy = self.player_y - y
 jarak = matematika.sqrt (dx ** 2 + di ** 2)
jika jarak < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), acak.randint(0, SCREEN_HEIGHT)))
elif jarak < 100:
 dx /= jarak
 dy / = jarak


 kecepatan = 3# Sesuaikan nilai kecepatan sesuai kebutuhan
 dx = mnt (maks (kecepatan dx *, -MAX_SPEED), MAX_SPEED)
 dy = mnt (maks (kecepatan dy *, -MAX_SPEED), MAX_SPEED)
 x += dx
 y += dy
 self.objects[i] = (x, y)

Mengontrol Tingkat Spawn

Anda juga dapat mengontrol kecepatan kemunculan objek baru dalam game. Sesuaikan kode untuk memasukkan penundaan antara pemijahan objek baru:

impor waktu
kelasMyGame(arcade. Jendela):
def__init__(diri, lebar, tinggi):
 super().__init__(lebar, tinggi)
 arcade.set_background_color (arcade.color. PUTIH)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


 self.objek = []
 self.last_spawn_time = waktu.waktu()


defmemperbarui(mandiri, waktu_delta):
# kendalikan tingkat pemijahan di sini
jika waktu.waktu() - self.last_spawn_time > SPAWN_DELAY:
jika len (self.objects) < MAX_OBJECTS:
 self.objects.append((random.randint(0, SCREEN_WIDTH), acak.randint(0, SCREEN_HEIGHT)))
 self.last_spawn_time = waktu.waktu()


untuk Saya di dalam rentang (len (self.objects)):
 x, y = self.objek[i]
 dx = self.player_x - x
 dy = self.player_y - y
 jarak = matematika.sqrt (dx ** 2 + di ** 2)


jika jarak < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), acak.randint(0, SCREEN_HEIGHT)))
elif jarak < 100:
 dx /= jarak
 dy / = jarak
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Sesuaikan SPAWN_DELAY Dan MAX_OBJECTS nilai untuk menemukan keseimbangan yang tepat untuk game Anda. Penundaan yang lebih lama atau jumlah objek maksimum yang lebih kecil akan membuat game tidak terlalu ramai. Padahal, penundaan yang lebih pendek atau maksimum yang lebih besar akan menambah kesulitan.

Jadikan Game Lebih Menyenangkan Menggunakan Benda Bergerak

Menambahkan objek bergerak acak ke dalam game dapat meningkatkan pengalaman keseluruhan secara signifikan. Mereka memperkenalkan ketidakpastian dan tantangan, membuat gameplay lebih menarik dan dinamis. Pemain harus beradaptasi dan bereaksi dengan cepat untuk menghindari tabrakan atau menangkap objek, dan itu akan memberikan rasa kegembiraan dan pencapaian.