Farih.co.id
Home Programming Cara Menyimpan dan Memuat Data Game di Arcade

Cara Menyimpan dan Memuat Data Game di Arcade

save and load screen

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 game sederhana dimana pemain bisa bergerak ke kiri dan ke 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:

 import arcade

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_SPEED = 5
blue = arcade.color.BLUE

class GameWindow(arcade.Window):
    def __init__(self, width, height):
        super().__init__(width, height)
        self.player_x = width // 2

    def on_draw(self):
        arcade.start_render()
        arcade.draw_rectangle_filled(self.game_state.player_x,
                                     50, 50, 50, blue)

    def update(self, delta_time):
        pass

    def on_key_press(self, key, modifiers):
        if key == arcade.key.LEFT:
            self.player_x -= PLAYER_SPEED
        elif key == arcade.key.RIGHT:
            self.player_x += PLAYER_SPEED

def main():
    window = GameWindow(SCREEN_WIDTH, SCREEN_HEIGHT)
    arcade.run()

if __name__ == '__main__':
    main()

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

game sederhana di arcade dengan objek pemain

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:

 class GameState:
    def __init__(self):
        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, buat kamus Python yang berisi data game yang relevan. Kemudian buat serial menjadi file JSON bernama simpan.json.

 import json

class GameWindow(arcade.Window):
    def __init__(self, width, height):
        super().__init__(width, height)
        self.game_state = GameState()

    def save_game(self):
        data = {
            'player_x': self.game_state.player_x
        }
        with open('save.json', 'w') as file:
            json.dump(data, file)
            print(data)

    def on_draw(self):
        arcade.start_render()
        arcade.draw_rectangle_filled(self.game_state.player_x,
                                     50, 50, 50, blue)

    def update(self, delta_time):
        pass

    def on_key_press(self, key, modifiers):
        if key == arcade.key.LEFT:
            self.game_state.player_x -= PLAYER_SPEED
        elif key == arcade.key.RIGHT:
            self.game_state.player_x += PLAYER_SPEED
        elif key == arcade.key.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:

 class GameWindow(arcade.Window):
    def __init__(self, width, height):
        super().__init__(width, height)
        self.game_state = GameState()
        self.load_game()

    def load_game(self):
        try:
            with open('save.json', 'r') as file:
                data = json.load(file)
                self.game_state.player_x = data['player_x']
        except FileNotFoundError:
            pass

    def on_key_press(self, key, modifiers):
        if key == arcade.key.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.

game arcade dengan objek pemain dan memuat data game

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. Anda dapat mengelola skor dan menyimpan skor tinggi menggunakan sistem ini. Buat file baru bernama high-score.py dan tambahkan kode dengan pembaruan di bawah ini:

 class GameWindow(arcade.Window):
    def __init__(self, width, height):
        super().__init__(width, height)
        self.high_score = 0

    def load_game(self):
        try:
            with open('save.json', 'r') as file:
                data = json.load(file)
                print(data)
                self.player_x = data.get('player_x', self.player_x)
                self.high_score = data.get('high_score', self.high_score)
        except FileNotFoundError:
            pass

    def save_game(self):
        data = {
            'player_x': self.player_x,
            'high_score': self.high_score
        }
        with open('save.json', 'w') as file:
            json.dump(data, file)
            print(data)

    def on_key_press(self, key, modifiers):
        if key == arcade.key.LEFT:
            self.player_x -= PLAYER_SPEED
        elif key == arcade.key.RIGHT:
            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:

 import time

class GameWindow(arcade.Window):
    def __init__(self, width, height):
        super().__init__(width, height)
        self.game_state = GameState()

       
       self.autosave_interval = 6
        self.last_save_time = time.time()

    def update(self, delta_time):
        current_time = time.time()
        time_diff = current_time - self.last_save_time

        if time_diff >= self.autosave_interval:
            self.save_game()
            print("Saved")
            self.last_save_time = current_time

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 game. 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:

 class GameState:
    def __init__(self):
        self.player_x = 0

    def save_state(self):
        if self.is_valid_state():
            data = {
                'player_x': self.player_x
            }

            with open('save.json', 'w') as file:
                json.dump(data, file)

    def load_state(self):
        with open('save.json', 'r') as file:
            data = json.load(file)

            if self.validate_loaded_data(data):
                self.player_x = data['player_x']
            else:
                print("Error!")

    def is_valid_state(self):
        
        
        pass

    def validate_loaded_data(self, data):
        
        
        pass

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

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 PermissionErrorselama 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.

Comment
Share:

Leave a Reply

Your email address will not be published. Required fields are marked *

beli jitu https://167.71.217.241/ https://188.166.210.27/ https://103.253.147.8/ https://139.59.194.132/ https://152.42.192.54/ https://152.42.187.123/ https://188.166.196.248/ https://163.47.9.78/ https://157.230.245.144/ http://68.183.96.87/ http://147.182.210.122/ http://147.182.128.234/ http://167.172.1.184/ http://157.245.5.74/ http://139.59.217.59/ http://163.47.9.16/ http://144.126.251.215/ http://139.59.217.128/ http://103.186.0.254/ http://161.35.251.176/ http://157.245.29.71/ https://170.64.254.102/ https://www.markas303.ac.id/ https://www.markas303.or.id/ https://www.markas303.sch.id/ http://103.172.205.75/ http://103.245.38.119/ http://138.197.224.231/ http://138.197.224.231/

Ad

BIJI18 BIJI18 https://goremekoop.com/ AGEN77 3DBET OBOR138 GACOR168JP YING77 RUMAH258 POHONHOKI99 ASALBET88 PARIS128 66KBET LONG111 DESA333 DEWAGACOR89 YING77
https://146.190.200.68/ https://188.166.204.36/