Como salvar e carregar dados do jogo no Arcade

Adicionar um sistema de salvar e carregar ao seu jogo pode melhorar muito a experiência do jogador. Ele permite que os jogadores persistam em seu progresso, retomem as sessões de jogo e experimentem diferentes estratégias sem perder as conquistas suadas.

Você ficará agradavelmente surpreso com a facilidade de adicionar esse recurso ao seu jogo usando a biblioteca Arcade do Python.

Crie um jogo simples

Comece criando um jogo simples onde o jogador pode se mover esquerda e direita.

O código usado neste artigo está disponível neste Repositório GitHub e é gratuito para você usar sob a licença do MIT.

Crie um novo arquivo chamado simple-game.py e adicione o código abaixo:

importar videogames
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_SPEED = 5
azul = arcade.color. AZUL
aulaGameWindow(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 self.player_x = largura // 2





instagram viewer

defon_draw(auto):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, azul)
defatualizar(auto, delta_time):
passar
defon_key_press(auto, chave, modificadores):
se chave == arcade.key. ESQUERDA:
 self.player_x -= PLAYER_SPEED
elif chave == arcade.key. CERTO:
 self.player_x += PLAYER_SPEED
defprincipal():
 janela = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
se __nome__ == '__principal__':
 principal()

O código cria uma janela com um retângulo azul representando o jogador. O jogador pode se mover para a esquerda e para a direita usando as teclas de seta para a esquerda e para a direita.

Gerenciando estados do jogo

Para implementar um sistema de salvar e carregar, você precisa gerenciar diferentes estados do jogo. Um estado do jogo representa o estado atual do jogo, incluindo as posições dos objetos, pontuações e outros dados relevantes. Para este exemplo, concentre-se apenas na coordenada x do jogador.

Para gerenciar os estados do jogo, introduza um GameState classe que encapsula os dados do jogo e fornece métodos para salvá-los e carregá-los. Aqui está o código:

aulaGameState:
def__iniciar__(auto):
 self.player_x = 0

Salvando os dados do jogo

Para salvar os dados do jogo, estenda o GameWindow class e adicione um método para salvar o estado do jogo sempre que necessário. Use o formato JSON para simplificar. Aqui está o código:

No salvar_jogo método, criar um dicionário Python contendo os dados relevantes do jogo. Em seguida, serialize-o em um arquivo JSON chamado salvar.json.

importar json
aulaGameWindow(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 self.game_state = GameState()
defsalvar_jogo(auto):
 dados = {
'jogador_x': self.game_state.player_x
 }
com abrir('salvar.json', 'c') como arquivo:
 json.dump (dados, arquivo)
 imprimir (dados)
defon_draw(auto):
 arcade.start_render()
 arcade.draw_rectangle_filled (self.game_state.player_x, 
50, 50, 50, azul)
defatualizar(auto, delta_time):
passar
defon_key_press(auto, chave, modificadores):
se chave == arcade.key. ESQUERDA:
 self.game_state.player_x -= PLAYER_SPEED
elif chave == arcade.key. CERTO:
 self.game_state.player_x += PLAYER_SPEED
elif chave == arcade.key. S:
 self.save_game()

Carregando os dados do jogo

Para carregar os dados do jogo, estenda o GameWindow classe ainda mais e adicione um método para carregar o estado do jogo. Crie um novo arquivo chamado load-game.py e adicione o código com as atualizações abaixo:

aulaGameWindow(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 self.game_state = GameState()
 self.load_game()
defcarregar jogo(auto):
tentar:
com abrir('salvar.json', 'r') como arquivo:
 dados = json.load (arquivo)
 self.game_state.player_x = dados['jogador_x']
exceto FileNotFoundError:
passar
defon_key_press(auto, chave, modificadores):
se chave == arcade.key. EU:
 self.load_game()

O carregar jogo método tenta abrir o salvar.json arquivo e recupere os dados do jogo. Em seguida, ele atualiza o estado do jogo com os dados carregados. Se o arquivo não existir, você pode simplesmente ignorar a exceção, deixando o estado padrão do jogo.

Incluindo Recursos Adicionais

Você pode adicionar mais recursos para aprimorar o sistema de salvar e carregar o jogo.

Salvando pontuações mais altas

Salvar as pontuações mais altas junto com o estado do jogo é um recurso comum em muitos jogos. Você pode gerenciar as pontuações e salve a pontuação mais alta usando este sistema. Crie um novo arquivo chamado pontuação alta.py e adicione o código com as atualizações abaixo:

aulaGameWindow(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 self.high_score = 0
defcarregar jogo(auto):
tentar:
com abrir('salvar.json', 'r') como arquivo:
 dados = json.load (arquivo)
 imprimir (dados)
 self.player_x = data.get('jogador_x', self.player_x)
 self.high_score = data.get('pontuação máxima', self.high_score)
exceto FileNotFoundError:
passar
defsalvar_jogo(auto):
 dados = {
'jogador_x': self.player_x,
'pontuação máxima': self.high_score
 }
com abrir('salvar.json', 'c') como arquivo:
 json.dump (dados, arquivo)
 imprimir (dados)
defon_key_press(auto, chave, modificadores):
se chave == arcade.key. ESQUERDA:
 self.player_x -= PLAYER_SPEED
elif chave == arcade.key. CERTO:
 self.player_x += PLAYER_SPEED
 self.high_score += 1

Recurso de salvamento automático

Para proporcionar tranquilidade aos jogadores e evitar a perda de progresso, você pode salvar automaticamente o estado do jogo em intervalos regulares. Crie um novo arquivo chamado auto-save.py e adicione o código com as atualizações abaixo:

importar tempo
aulaGameWindow(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 self.game_state = GameState()
# Salve a cada 6 segundos
 self.autosave_interval = 6
 self.last_save_time = time.time()
defatualizar(auto, delta_time):
 hora_atual = hora.hora()
 time_diff = current_time - self.last_save_time
se time_diff >= self.autosave_interval:
 self.save_game()
 imprimir("Salvou")
 self.last_save_time = current_time

Neste trecho de código, o atualizar O método verifica se o intervalo de tempo especificado passou desde o último salvamento. Em caso afirmativo, ele aciona o salvar_jogo método do GameWindow class para salvar automaticamente o estado do jogo. Ajusta a autosave_interval valor de acordo com os requisitos do seu jogo.

Validando dados do jogo

Validar os dados do jogo carregado é essencial para garantir sua integridade e consistência. Você pode incorporar facilmente a validação de dados em nosso sistema de salvar e carregar:

aulaGameState:
def__iniciar__(auto):
 self.player_x = 0
defEstado salvo(auto):
se self.is_valid_state():
 dados = {
'jogador_x': self.player_x
 }
com abrir('salvar.json', 'c') como arquivo:
 json.dump (dados, arquivo)
defload_state(auto):
com abrir('salvar.json', 'r') como arquivo:
 dados = json.load (arquivo)
se self.validate_loaded_data (dados):
 self.player_x = dados['jogador_x']
outro:
 imprimir("Erro!")
defis_valid_state(auto):
# Execute a lógica de validação aqui
# Retorna True se o estado for válido, False caso contrário
passar
defvalid_loaded_data(auto, dados):
# Executa a validação nos dados carregados
# Retorna True se os dados forem válidos, False caso contrário
passar

Ao incorporar esses recursos adicionais ao sistema de salvar e carregar, você pode criar uma jogabilidade mais versátil e robusta experiência, oferecendo aos jogadores a capacidade de salvar vários estados do jogo, rastrear pontuações mais altas, habilitar o salvamento automático e garantir dados integridade.

Melhores práticas para o sistema de salvar e carregar

A implementação de um sistema de salvar e carregar é um aspecto importante do desenvolvimento do jogo. Para garantir um sistema robusto e confiável, é essencial seguir as melhores práticas. Aqui estão algumas práticas importantes a serem consideradas:

Criptografar dados confidenciais

Se o seu jogo incluir informações confidenciais, como senhas, dados pessoais ou compras no aplicativo, é crucial criptografar o estado do jogo salvo. A criptografia adiciona uma camada extra de segurança, protegendo a privacidade do jogador e impedindo o acesso não autorizado aos seus dados. Utilize algoritmos de criptografia e bibliotecas para proteger informações confidenciais.

Validar dados carregados

Antes de carregar os dados do jogo, é essencial validá-los para garantir sua integridade e consistência. Verifique se os dados carregados estão de acordo com o formato, estrutura e restrições esperados do seu jogo.

Realize verificações de validação em campos de dados críticos para evitar travamentos ou trapaças. Implemente mecanismos robustos de validação de dados para lidar com possíveis erros ou dados inesperados.

Lide com erros graciosamente

Ao lidar com operações de E/S de arquivo, podem ocorrer erros. É crucial lidar com esses erros graciosamente e fornecer mensagens de erro informativas ao jogador. Capture e trate exceções, como FileNotFoundError ou PermissionError, durante as operações de salvar e carregar.

Exiba mensagens de erro fáceis de usar para orientar os jogadores e evitar frustrações. Além disso, considere implementar o registro de erros para ajudar a diagnosticar e corrigir problemas.

Teste a funcionalidade de salvar e carregar

Teste minuciosamente a funcionalidade de salvar e carregar do seu jogo para garantir sua confiabilidade e correção. Crie casos de teste que cubram vários cenários, como salvar em diferentes estados do jogo, carregar de arquivos salvos válidos e inválidos e testar casos extremos.

Valide se o estado do jogo foi salvo e carregado corretamente e se o comportamento esperado ocorre. As estruturas de teste automatizadas podem ajudar na criação de suítes de teste abrangentes.

Torne os jogos mais divertidos com o sistema de salvar e carregar

Adicionar um sistema de salvar e carregar pode tornar os jogos mais envolventes, proporcionando aos jogadores uma sensação de continuidade e progresso. Os jogadores podem experimentar livremente, tentar abordagens diferentes e retornar ao jogo mais tarde sem perder suas conquistas.

Esse recurso também permite que os jogadores compitam com amigos ou se desafiem a superar suas pontuações mais altas anteriores, adicionando rejogabilidade e envolvimento de longo prazo ao seu jogo.