PlayerPrefs: O “Salvar Jogo” Mais Fácil da Unity (Tutorial Direto ao Ponto)

Seu Jogo Tem Amnésia? Como Salvar o Score com PlayerPrefs (em 3 Linhas de Código)

Seu jogo funciona perfeitamente. Na mesma sessão. Você joga, faz 1000 pontos, morre, e o menu principal mostra seu novo high score.

Aí você fecha o editor da Unity (ou o jogo compilado) e abre de novo.

O high score voltou a ser 0.

Isso acontece porque as variáveis do seu script vivem na memória RAM. Elas são temporárias. Quando o jogo fecha, a memória é limpa. Para os dados sobreviverem, eles precisam ser escritos no disco rígido (armazenamento permanente).

É exatamente isso que o PlayerPrefs faz, só que ele esconde toda a complexidade de você.

O que é o PlayerPrefs?

Pense no PlayerPrefs como um pequeno “bloco de notas” ou um dicionário que a Unity guarda para o seu jogo. Ele só sabe lidar com 3 tipos de dados:

1. Int (números inteiros – para scores, número do nível, etc.)
2. Float (números com vírgula – para volume, sensibilidade do mouse, etc.)
3. String (texto – para o nome do jogador, etc.)

É isso. Você não pode salvar um GameObject ou um Vector3 inteiro. E para começar, isso é ótimo.

O Tutorial: Salvando um High Score

Vamos criar um sistema de high score super simples.

Crie um script C# chamado GerenciadorDeScore.

using UnityEngine;
using TMPro; // Não esqueça de importar o TextMeshPro

public class GerenciadorDeScore : MonoBehaviour
{
    // A chave" que vamos usar para salvar e buscar o dado
    // É como o nome do arquivo no nosso "bloco de notas"
    private const string CHAVE_HIGHSCORE = "MeuHighScore"; 

    public TextMeshProUGUI textoHighScoreMenu;
    public TextMeshProUGUI textoScoreAtual;

    private int scoreAtual = 0;
    private int highScore = 0;

    void Start()
    {
        // 1. CARREGAR OS DADOS
        // Quando o jogo começa, tentamos carregar o high score salvo
        // O "0" é o valor padrão caso a chave não exista
        highScore = PlayerPrefs.GetInt(CHAVE_HIGHSCORE, 0);

        AtualizarUIText();
    }

    // Chame isso de outro script (ex: quando o jogador coleta uma moeda)
    public void AdicionarScore(int pontos)
    {
        scoreAtual += pontos;
        AtualizarUIText();
    }

    // Chame isso quando o jogador morrer (ex: no script do Player)
    public void SalvarScoreAoMorrer()
    {
        if (scoreAtual > highScore)
        {
            highScore = scoreAtual; // Atualiza o high score na memória

            // 2. SALVAR OS DADOS
            // Aqui está a mágica. Pedimos para o PlayerPrefs guardar o valor
            PlayerPrefs.SetInt(CHAVE_HIGHSCORE, highScore);

            // Opcional, mas recomendado: Força o salvamento imediato
            PlayerPrefs.Save(); 

            Debug.Log("Novo High Score salvo: " + highScore);
        }

        // Reseta o score atual para a próxima rodada
        scoreAtual = 0;
        AtualizarUIText();
    }

    void AtualizarUIText()
    {
        // Mostra o score atual (se estiver configurado)
        if (textoScoreAtual != null)
        {
            textoScoreAtual.text = "Score: " + scoreAtual;
        }

        // Mostra o high score (se estiver configurado)
        if (textoHighScoreMenu != null)
        {
            textoHighScoreMenu.text = "High Score: " + highScore;
        }
    }

    // --- FUNÇÃO DE TESTE ---
    // Para limpar o high score salvo no editor
    [ContextMenu("Limpar High Score (Resetar PlayerPrefs)")]
    public void LimparPlayerPrefs()
    {
        PlayerPrefs.DeleteKey(CHAVE_HIGHSCORE);
        // Ou para apagar TUDO:
        // PlayerPrefs.DeleteAll();
        
        highScore = 0;
        AtualizarUIText();
        Debug.Log("High Score resetado.");
    }
}

A Lógica em 3 Passos

Viu como é simples? O fluxo todo se resume a:

1. Carregar (no Start):highScore = PlayerPrefs.GetInt("MinhaChave", 0);
   • Tradução: “Tente buscar um inteiro salvo com a chave ‘MinhaChave’. Se não encontrar, me devolva 0.”
2. Salvar (quando precisa):PlayerPrefs.SetInt("MinhaChave", novoValor);
   • Tradução: “Guarde este novoValor no bloco de notas, usando a etiqueta ‘MinhaChave’.”
3. Confirmar (opcional):PlayerPrefs.Save();
   • Tradução: “Escreva agora o bloco de notas no disco.” (A Unity geralmente faz isso quando o jogo fecha, mas é bom forçar se o dado for crítico).

Como Usar

1. Crie um objeto vazio _GerenciadorDeScore e coloque o script nele.
2. Crie os textos de UI (TextMeshPro) para o score atual e o high score.
3. Arraste os textos para os campos corretos (textoHighScoreMenu, textoScoreAtual) no Inspector do script.
4. No seu script do Jogador (ou onde o score é contado), pegue uma referência a este GerenciadorDeScore.
5. Quando o jogador pegar uma moeda, chame gerenciadorDeScore.AdicionarScore(10).
6. Quando o jogador morrer, chame gerenciadorDeScore.SalvarScoreAoMorrer().

Testando

Jogue. Faça alguns pontos (ex: 50). Pare o jogo (simulando a morte do jogador, chamando SalvarScoreAoMorrer()). O console deve dizer “Novo High Score salvo: 50”.

Agora, o mais importante: Pare o Play Mode da Unity e dê Play de novo.

Observe o seu textoHighScoreMenu. Ele deve começar direto em “High Score: 50”.

Funcionou. Seu jogo não tem mais amnésia.

Para resetar e testar de novo: Selecione o _GerenciadorDeScore, clique com o botão direito no script (no Inspector) e escolha “Limpar High Score (Resetar PlayerPrefs)”.

Conclusão

PlayerPrefs é a sua ferramenta de entrada para persistência de dados. É simples, é rápida e resolve a maioria dos problemas de jogos pequenos e médios.

Não se preocupe com arquivos JSON ou bancos de dados até você realmente precisar salvar inventários complexos ou mundos inteiros. Para score, opções e progresso de níveis, o PlayerPrefs é o caminho.