A meno che il tuo gioco non sia molto breve, è utile poter salvare i progressi. Anche i giochi brevi possono trarre vantaggio dal salvataggio dei punteggi più alti.
L'aggiunta di un sistema di salvataggio e caricamento al tuo gioco può migliorare notevolmente l'esperienza del giocatore. Consente ai giocatori di mantenere i propri progressi, riprendere le sessioni di gioco e sperimentare diverse strategie senza perdere i risultati guadagnati duramente.
Sarai piacevolmente sorpreso da quanto sia semplice aggiungere questa funzionalità al tuo gioco utilizzando la libreria Arcade di Python.
Crea un gioco semplice
Inizia creando un semplice gioco in cui il giocatore può muoversi sinistra e destra.
Il codice utilizzato in questo articolo è disponibile in this Deposito GitHub ed è gratuito per l'uso con la licenza MIT.
Crea un nuovo file denominato gioco-semplice.py e aggiungi il codice seguente:
importare sala giochiSCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
GIOCATORE_VELOCITÀ = 5
blu = arcade.color. BLUclasseFinestra di gioco(sala giochi. Finestra):
def__dentro__(auto, larghezza, altezza):
super().__init__(larghezza, altezza)
self.player_x = larghezza // 2defon_draw(se stesso):
arcade.start_render()
arcade.draw_rectangle_filled (self.game_state.player_x,
50, 50, 50, blu)defaggiornamento(self, delta_time):
passaggiodefon_key_press(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA:
self.player_x -= PLAYER_SPEED
elif chiave == arcade.chiave. GIUSTO:
self.player_x += PLAYER_SPEEDdefprincipale():
finestra = Finestra di gioco (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
Se __nome__ == '__principale__':
principale()
Il codice crea una finestra con un rettangolo blu che rappresenta il giocatore. Il giocatore può spostarsi a sinistra ea destra usando i tasti freccia sinistra e destra.
Gestione degli stati di gioco
Per implementare un sistema di salvataggio e caricamento, devi gestire diversi stati di gioco. Uno stato di gioco rappresenta lo stato corrente del gioco, comprese le posizioni degli oggetti, i punteggi e altri dati rilevanti. Per questo esempio, concentrati solo sulla coordinata x del giocatore.
Per gestire gli stati del gioco, introdurre a Stato del gioco class che incapsula i dati del gioco e fornisce metodi per salvarli e caricarli. Ecco il codice:
classeStato del gioco:
def__dentro__(se stesso):
self.player_x = 0Salvataggio dei dati di gioco
Per salvare i dati di gioco, estendi il file Finestra di gioco class e aggiungere un metodo per salvare lo stato del gioco quando necessario. Usa il formato JSON per semplicità. Ecco il codice:
Nel salva il gioco metodo, creare un dizionario Python contenente i relativi dati di gioco. Quindi serializzalo in un file JSON chiamato save.json.
importare jsonclasseFinestra di gioco(sala giochi. Finestra):
def__dentro__(auto, larghezza, altezza):
super().__init__(larghezza, altezza)
self.game_state = GameState()defsalva il gioco(se stesso):
dati = {
'giocatore_x': self.game_state.player_x
}
con aprire('salva.json', 'w') COME file:
json.dump (dati, file)
stampa (dati)defon_draw(se stesso):
arcade.start_render()
arcade.draw_rectangle_filled (self.game_state.player_x,
50, 50, 50, blu)defaggiornamento(self, delta_time):
passaggio
defon_key_press(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA:
self.game_state.player_x -= PLAYER_SPEED
elif chiave == arcade.chiave. GIUSTO:
self.game_state.player_x += PLAYER_SPEED
elif chiave == arcade.chiave. S:
self.save_game()
Caricamento dei dati di gioco
Per caricare i dati di gioco, estendi il file Finestra di gioco class ulteriormente e aggiungi un metodo per caricare lo stato del gioco. Crea un nuovo file denominato carica-gioco.py e aggiungi il codice con i seguenti aggiornamenti:
classeFinestra di gioco(sala giochi. Finestra):
def__dentro__(auto, larghezza, altezza):
super().__init__(larghezza, altezza)
self.game_state = GameState()
self.load_game()defcarica_gioco(se stesso):
Tentativo:
con aprire('salva.json', 'R') COME file:
dati = json.load (file)
self.game_state.player_x = dati['giocatore_x']
tranne FileNotFoundError:
passaggio
defon_key_press(self, chiave, modificatori):
Se chiave == arcade.chiave. L:
self.load_game()
IL carica_gioco Il metodo tenta di aprire il file save.json file e recuperare i dati di gioco. Quindi aggiorna lo stato del gioco con i dati caricati. Se il file non esiste, puoi semplicemente ignorare l'eccezione, lasciando lo stato di gioco predefinito.
Comprese funzionalità aggiuntive
Puoi aggiungere altre funzionalità per migliorare il sistema di salvataggio e caricamento del gioco.
Salvare i punteggi più alti
Il salvataggio dei punteggi più alti insieme allo stato del gioco è una caratteristica comune in molti giochi. Puoi gestire i punteggi e salva il punteggio più alto usando questo sistema. Crea un nuovo file denominato high-score.py e aggiungi il codice con i seguenti aggiornamenti:
classeFinestra di gioco(sala giochi. Finestra):
def__dentro__(auto, larghezza, altezza):
super().__init__(larghezza, altezza)
self.high_score = 0defcarica_gioco(se stesso):
Tentativo:
con aprire('salva.json', 'R') COME file:
dati = json.load (file)
stampa (dati)
self.player_x = dati.get('giocatore_x', self.giocatore_x)
self.high_score = dati.get('punteggio alto', self.high_score)
tranne FileNotFoundError:
passaggiodefsalva il gioco(se stesso):
dati = {
'giocatore_x': self.player_x,
'punteggio alto': self.high_score
}
con aprire('salva.json', 'w') COME file:
json.dump (dati, file)
stampa (dati)
defon_key_press(self, chiave, modificatori):
Se chiave == arcade.chiave. SINISTRA:
self.player_x -= PLAYER_SPEED
elif chiave == arcade.chiave. GIUSTO:
self.player_x += PLAYER_SPEED
self.high_score += 1
Funzione di salvataggio automatico
Per offrire tranquillità ai giocatori e prevenire la perdita di progressi, puoi salvare automaticamente lo stato del gioco a intervalli regolari. Crea un nuovo file denominato salvataggio automatico.py e aggiungi il codice con i seguenti aggiornamenti:
importare tempoclasseFinestra di gioco(sala giochi. Finestra):
def__dentro__(auto, larghezza, altezza):
super().__init__(larghezza, altezza)
self.game_state = GameState()# Salva ogni 6 secondi
self.autosave_interval = 6
self.last_save_time = tempo.tempo()defaggiornamento(self, delta_time):
ora_corrente = ora.ora()
time_diff = current_time - self.last_save_time
Se time_diff >= self.autosave_interval:
self.save_game()
stampa("Salvato")
self.last_save_time = current_time
In questo frammento di codice, il aggiornamento Il metodo controlla se l'intervallo di tempo specificato è trascorso dall'ultimo salvataggio. In tal caso, attiva il salva il gioco metodo del Finestra di gioco class per salvare automaticamente lo stato del gioco. Aggiusta il autosave_interval valore in base ai requisiti del tuo gioco.
Convalida dei dati di gioco
La convalida dei dati di gioco caricati è essenziale per garantirne l'integrità e la coerenza. Puoi facilmente incorporare la convalida dei dati nel nostro sistema di salvataggio e caricamento:
classeStato del gioco:
def__dentro__(se stesso):
self.player_x = 0defsave_state(se stesso):
Se self.is_valid_state():
dati = {
'giocatore_x': self.player_x
}con aprire('salva.json', 'w') COME file:
json.dump (dati, file)defcarico_stato(se stesso):
con aprire('salva.json', 'R') COME file:
dati = json.load (file)Se self.validate_loaded_data (dati):
self.player_x = dati['giocatore_x']
altro:
stampa("Errore!")defis_valid_state(se stesso):
# Esegui qui la logica di validazione
# Restituisce True se lo stato è valido, False in caso contrario
passaggio
defvalidate_loaded_data(sé, dati):
# Eseguire la convalida sui dati caricati
# Restituisce True se i dati sono validi, False in caso contrario
passaggio
Incorporando queste funzionalità aggiuntive nel sistema di salvataggio e caricamento, puoi creare un gameplay più versatile e solido esperienza, offrendo ai giocatori la possibilità di salvare più stati di gioco, tenere traccia dei punteggi più alti, abilitare il salvataggio automatico e garantire i dati integrità.
Best practice per il sistema di salvataggio e caricamento
L'implementazione di un sistema di salvataggio e caricamento è un aspetto importante dello sviluppo del gioco. Per garantire un sistema robusto e affidabile, è essenziale seguire le best practice. Ecco alcune pratiche chiave da considerare:
Crittografare i dati sensibili
Se il tuo gioco include informazioni sensibili come password, dati personali o acquisti in-app, è fondamentale crittografare lo stato del gioco salvato. La crittografia aggiunge un ulteriore livello di sicurezza, proteggendo la privacy del giocatore e impedendo l'accesso non autorizzato ai propri dati. Utilizza algoritmi e librerie di crittografia per salvaguardare le informazioni sensibili.
Convalida dati caricati
Prima di caricare i dati di gioco, è essenziale convalidarli per garantirne l'integrità e la coerenza. Verifica che i dati caricati aderiscano al formato, alla struttura e ai vincoli previsti del tuo gioco.
Esegui controlli di convalida sui campi di dati critici per evitare arresti anomali o imbrogli. Implementa solidi meccanismi di convalida dei dati per gestire potenziali errori o dati imprevisti.
Gestisci gli errori con garbo
Quando si tratta di operazioni di I/O su file, possono verificarsi errori. È fondamentale gestire questi errori con garbo e fornire messaggi di errore informativi al giocatore. Cattura e gestisci le eccezioni, ad esempio FileNotFoundError O Errore di autorizzazione, durante le operazioni di salvataggio e caricamento.
Visualizza messaggi di errore intuitivi per guidare i giocatori e prevenire la frustrazione. Inoltre, prendere in considerazione l'implementazione della registrazione degli errori per aiutare a diagnosticare e risolvere i problemi.
Testare la funzionalità di salvataggio e caricamento
Testare accuratamente la funzionalità di salvataggio e caricamento del gioco per garantirne l'affidabilità e la correttezza. Crea casi di test che coprono vari scenari, come il salvataggio in diversi stati di gioco, il caricamento da file di salvataggio validi e non validi e il test di casi limite.
Verifica che lo stato del gioco sia stato salvato e caricato correttamente e che si verifichi il comportamento previsto. I framework di test automatizzati possono aiutare a creare suite di test complete.
Rendi i giochi più divertenti con il sistema di salvataggio e caricamento
L'aggiunta di un sistema di salvataggio e caricamento può rendere i giochi più coinvolgenti fornendo ai giocatori un senso di continuità e progresso. I giocatori possono sperimentare liberamente, provare approcci diversi e tornare al gioco in un secondo momento senza perdere i propri risultati.
Questa funzione consente inoltre ai giocatori di competere con gli amici o sfidare se stessi per battere i loro record precedenti, aggiungendo rigiocabilità e coinvolgimento a lungo termine al tuo gioco.
