Kecuali jika permainan Anda sangat singkat, ada baiknya menyimpan kemajuan. Bahkan game pendek pun bisa mendapatkan keuntungan dari menyimpan skor tinggi.

Menambahkan sistem simpan dan muat ke gim Anda dapat sangat meningkatkan pengalaman pemain. Ini memungkinkan pemain untuk mempertahankan kemajuan mereka, melanjutkan sesi permainan, dan bereksperimen dengan berbagai strategi tanpa kehilangan pencapaian yang diperoleh dengan susah payah.

Anda akan terkejut dengan betapa mudahnya menambahkan fitur ini ke game Anda menggunakan pustaka Arcade Python.

Buat Game Sederhana

Mulailah dengan membuat permainan sederhana di mana pemain bisa bergerak kiri dan kanan.

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

Buat file baru bernama simple-game.py dan tambahkan kode di bawah ini:

impor arcade
SCREEN_WIDTH = 800
LAYAR_TINGGI = 600
PEMAIN_KECEPATAN = 5
biru = arcade.color. BIRU


kelasGameWindow(arcade. Jendela):
def__init__(diri, lebar, tinggi):
 super().__init__(lebar, tinggi)
 self.player_x = lebar // 2







instagram viewer



defon_draw(diri sendiri):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, biru)


defmemperbarui(mandiri, waktu_delta):
lulus


defon_key_press(mandiri, kunci, pengubah):
jika kunci == arcade.kunci. KIRI:
 self.player_x -= PLAYER_SPEED
elif kunci == arcade.kunci. BENAR:
 self.player_x += PLAYER_SPEED


defutama():
 jendela = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.lari()
jika __nama__ == '__utama__':
 utama()

Kode membuat jendela dengan persegi panjang biru yang mewakili pemain. Pemain dapat bergerak ke kiri dan ke kanan menggunakan tombol panah kiri dan kanan.

Mengelola Status Game

Untuk menerapkan sistem simpan dan muat, Anda perlu mengelola status permainan yang berbeda. Status game mewakili status game saat ini, termasuk posisi objek, skor, dan data relevan lainnya. Untuk contoh ini, fokuskan hanya pada koordinat x pemain.

Untuk mengelola status game, perkenalkan a Status permainan kelas yang merangkum data game dan menyediakan metode untuk menyimpan dan memuatnya. Ini kodenya:

kelasStatus permainan:
def__init__(diri sendiri):
 self.player_x = 0

Menyimpan Data Permainan

Untuk menyimpan data game, perpanjang GameWindow kelas dan tambahkan metode untuk menyimpan status game kapan pun diperlukan. Gunakan format JSON untuk kesederhanaan. Ini kodenya:

Dalam Simpan permainan metode, membuat kamus Python berisi data permainan yang relevan. Kemudian buat serial menjadi file JSON bernama simpan.json.

impor json
kelasGameWindow(arcade. Jendela):
def__init__(diri, lebar, tinggi):
 super().__init__(lebar, tinggi)
 self.game_state = GameState()


defSimpan permainan(diri sendiri):
 data = {
'pemain_x': self.game_state.player_x
 }
dengan membuka('simpan.json', 'w') sebagai mengajukan:
 json.dump (data, file)
 cetak (data)


defon_draw(diri sendiri):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, biru)


defmemperbarui(mandiri, waktu_delta):
lulus
defon_key_press(mandiri, kunci, pengubah):
jika kunci == arcade.kunci. KIRI:
 self.game_state.player_x -= PLAYER_SPEED
elif kunci == arcade.kunci. BENAR:
 self.game_state.player_x += PLAYER_SPEED
elif kunci == arcade.kunci. S:
 self.save_game()

Memuat Data Permainan

Untuk memuat data game, perpanjang GameWindow kelas lebih lanjut dan tambahkan metode untuk memuat status game. Buat file baru bernama load-game.py dan tambahkan kode dengan pembaruan di bawah ini:

kelasGameWindow(arcade. Jendela):
def__init__(diri, lebar, tinggi):
 super().__init__(lebar, tinggi)
 self.game_state = GameState()
 self.load_game()
defload_game(diri sendiri):
mencoba:
dengan membuka('simpan.json', 'R') sebagai mengajukan:
 data = json.load (file)
 self.game_state.player_x = data['pemain_x']
kecuali FileNotFoundError:
lulus
defon_key_press(mandiri, kunci, pengubah):
jika kunci == arcade.kunci. L:
 self.load_game()

Itu load_game metode mencoba untuk membuka simpan.json file dan mengambil data permainan. Itu kemudian memperbarui status game dengan data yang dimuat. Jika file tidak ada, Anda bisa mengabaikan pengecualian, membiarkan status game default.

Termasuk Fitur Tambahan

Anda dapat menambahkan lebih banyak fitur untuk meningkatkan sistem penyimpanan dan pemuatan game.

Menyimpan Skor Tinggi

Menyimpan skor tinggi di samping status game adalah fitur umum di banyak game. Kamu bisa mengelola skor dan simpan skor tinggi menggunakan sistem ini. Buat file baru bernama high-score.py dan tambahkan kode dengan pembaruan di bawah ini:

kelasGameWindow(arcade. Jendela):
def__init__(diri, lebar, tinggi):
 super().__init__(lebar, tinggi)
 self.high_score = 0
defload_game(diri sendiri):
mencoba:
dengan membuka('simpan.json', 'R') sebagai mengajukan:
 data = json.load (file)
 cetak (data)
 self.player_x = data.get('pemain_x', self.player_x)
 self.high_score = data.get('skor tinggi', self.high_score)
kecuali FileNotFoundError:
lulus


defSimpan permainan(diri sendiri):
 data = {
'pemain_x': self.player_x,
'skor tinggi': self.high_score
 }
dengan membuka('simpan.json', 'w') sebagai mengajukan:
 json.dump (data, file)
 cetak (data)
defon_key_press(mandiri, kunci, pengubah):
jika kunci == arcade.kunci. KIRI:
 self.player_x -= PLAYER_SPEED
elif kunci == arcade.kunci. BENAR:
 self.player_x += PLAYER_SPEED
 self.high_score += 1

Fitur Penyimpanan Otomatis

Untuk memberikan ketenangan pikiran kepada pemain dan mencegah hilangnya kemajuan, Anda dapat secara otomatis menyimpan status permainan secara berkala. Buat file baru bernama penyimpanan otomatis.py dan tambahkan kode dengan pembaruan di bawah ini:

impor waktu
kelasGameWindow(arcade. Jendela):
def__init__(diri, lebar, tinggi):
 super().__init__(lebar, tinggi)
 self.game_state = GameState()


# Simpan setiap 6 detik
 self.autosave_interval = 6
 self.last_save_time = waktu.waktu()


defmemperbarui(mandiri, waktu_delta):
 saat_waktu = waktu.waktu()
 time_diff = waktu_saat ini - waktu_sendiri.last_save
jika time_diff >= self.autosave_interval:
 self.save_game()
 mencetak("Diselamatkan")
 self.last_save_time = waktu_terkini

Dalam cuplikan kode ini, file memperbarui metode memeriksa apakah interval waktu yang ditentukan telah berlalu sejak penyimpanan terakhir. Jika demikian, itu memicu Simpan permainan metode dari GameWindow kelas untuk secara otomatis menyimpan status permainan. Sesuaikan autosave_interval nilai sesuai dengan kebutuhan game Anda.

Memvalidasi Data Game

Memvalidasi data game yang dimuat sangat penting untuk memastikan integritas dan konsistensinya. Anda dapat dengan mudah memasukkan validasi data ke dalam sistem simpan dan muat kami:

kelasStatus permainan:
def__init__(diri sendiri):
 self.player_x = 0
defsave_state(diri sendiri):
jika self.is_valid_state():
 data = {
'pemain_x': self.player_x
 }


dengan membuka('simpan.json', 'w') sebagai mengajukan:
 json.dump (data, file)


defstatus_beban(diri sendiri):
dengan membuka('simpan.json', 'R') sebagai mengajukan:
 data = json.load (file)


jika self.validate_loaded_data (data):
 self.player_x = data['pemain_x']
kalau tidak:
 mencetak("Kesalahan!")


defis_valid_state(diri sendiri):
# Lakukan logika validasi di sini
# Kembalikan True jika status valid, False jika tidak
lulus
defvalidasi_loaded_data(diri, data):
# Lakukan validasi pada data yang dimuat
# Kembalikan True jika data valid, False jika tidak
lulus

Dengan memasukkan fitur tambahan ini ke dalam sistem simpan dan muat, Anda dapat membuat gameplay yang lebih fleksibel dan kuat pengalaman, menawarkan pemain kemampuan untuk menyimpan beberapa status game, melacak skor tinggi, mengaktifkan penyimpanan otomatis, dan memastikan data integritas.

Praktik Terbaik untuk Sistem Simpan dan Muat

Menerapkan sistem simpan dan muat merupakan aspek penting dari pengembangan game. Untuk memastikan sistem yang kuat dan andal, penting untuk mengikuti praktik terbaik. Berikut adalah beberapa praktik utama untuk dipertimbangkan:

Enkripsi Data Sensitif

Jika game Anda menyertakan informasi sensitif seperti sandi, data pribadi, atau pembelian dalam aplikasi, penting untuk mengenkripsi status game tersimpan. Enkripsi menambah lapisan keamanan ekstra, melindungi privasi pemain dan mencegah akses tidak sah ke data mereka. Manfaatkan algoritme dan pustaka enkripsi untuk melindungi informasi sensitif.

Validasi Data yang Dimuat

Sebelum memuat data game, penting untuk memvalidasinya guna memastikan integritas dan konsistensinya. Verifikasi bahwa data yang dimuat sesuai dengan format, struktur, dan batasan yang diharapkan dari game Anda.

Lakukan pemeriksaan validasi pada bidang data penting untuk menghindari kerusakan atau kecurangan. Terapkan mekanisme validasi data yang kuat untuk menangani potensi kesalahan atau data yang tidak terduga.

Tangani Kesalahan dengan Anggun

Saat menangani operasi I/O file, kesalahan dapat terjadi. Sangat penting untuk menangani kesalahan ini dengan baik dan memberikan pesan kesalahan yang informatif kepada pemain. Tangkap dan tangani pengecualian, seperti FileNotFoundError atau PermissionError, selama operasi simpan dan muat.

Tampilkan pesan kesalahan yang ramah pengguna untuk memandu pemain dan mencegah frustrasi. Selain itu, pertimbangkan untuk menerapkan log kesalahan untuk membantu mendiagnosis dan memperbaiki masalah.

Uji Fungsi Simpan dan Muat

Uji secara menyeluruh fungsi simpan dan muat game Anda untuk memastikan keandalan dan kebenarannya. Buat kasus pengujian yang mencakup berbagai skenario, seperti menyimpan dalam status permainan yang berbeda, memuat dari file penyimpanan yang valid dan tidak valid, dan menguji kasus edge.

Validasi bahwa status game disimpan dan dimuat dengan benar dan bahwa perilaku yang diharapkan terjadi. Kerangka pengujian otomatis dapat membantu dalam membuat rangkaian pengujian yang komprehensif.

Jadikan Game Lebih Menyenangkan Dengan Sistem Simpan dan Muat

Menambahkan sistem simpan dan muat dapat membuat game lebih menarik dengan memberi pemain rasa kontinuitas dan kemajuan. Pemain dapat bereksperimen dengan bebas, mencoba pendekatan yang berbeda, dan kembali ke permainan nanti tanpa kehilangan pencapaian mereka.

Fitur ini juga memungkinkan pemain untuk bersaing dengan teman atau menantang diri mereka sendiri untuk mengalahkan skor tinggi sebelumnya, menambahkan replayability dan interaksi jangka panjang ke game Anda.