[TUTORIAL] Salvar dados com playerprefs facilmente.

Olá, hoje compartilho com você um script que fiz algum tempo para dar suporte quando for salvar alguma variavel com PlayerPrefs. Este script facilita salvar pois ele possui comandos simples e rapidos para salvar, utilizando void's publicas para salvar e funções para recarregar os valores salvos. Este script salva os seguintes tipos de variáveis:

- Float,
- Int,
- Bool,
- String,
- Double,
- Vector2,
- Vector3,
- Quaternion,
 
 Salvando também todos esses tipos de variaveis em formato de Array, Float[], Int[]...

 Para utilizá-lo, você deve criar um script com o nome "PlayerPrefsEasySave", copiar o código abaixo e colar no script criado, após isso você deve trocar a classe do script do seu Save de:

MonoBehaviour


Para: PlayerPrefsEasySave



 Após fazer esse passo seu script de save terá dois novos elementos, um Enum contendo o nome da extensão que você irá usar para salvar seus dados, nessa versão do script esta disponível apenas o PlayerPrefs, e uma variável Int para você colocar o ID de sua cena (Isso é utilizado para poder salvar as mesmas Chaves independente da cena).
 Agora seu script já tem as void's e funções necessárias para utilizar o novo modo de save e load, partimos agora para aprender como usar esse script.

Para salvar qualquer tipo de variável você deve escrever a palavra "save" e encontrar o tipo de variável que você deseja salvar:


No caso iremos salvar uma variável float, com o seguinte código:

Código:

public float money;

 void Start () {
 SaveFloat ("Money", money); //Quando a void for chamada ela precisa do nome da Chave que você irá salvar e a variável
                                           //que deseja salvar... SaveFloat(Chave, Variável);
 }

E para carregar o valor salvo deve se usar o mesmo comando, mas ao invés escrever "save" na busca, você deve primeiro colocar a sua variável antes do código de load e um sinal de igual (=), lógo após, deve escrever "Load" e encontrar a variável que deseja recarregar, no caso uma float:

Código:

public float money;

 void Start () {
 money = LoadFloat ("Money"); //Quando a função de load for chamada ela precisa ser preenchida com apenas o nome da Chave
                                            //que você salvou anteriormente... LoadFloat(Chave);
 }

Lembrando, o nome de cada chave deve ser unica, ou seja, você não pode salvar duas variáveis com o mesmo nome na Chave, independente de serem variáveis diferentes. Apenas em cenas diferentes que podem ser salvas chaves iguais (com este script de save).

O mesmo você faz com outros tipos de variável que não sejam Array:

Código:

void Start () {
 //Salvar
 SaveFloat ("Chave", valorFloat);
 SaveInt ("Chave", valorInt);
 SaveBool ("Chave", valorBool); //0 ou 1
 SaveDouble ("Chave", valorDouble);

 //Carregar
 variavelFloat = LoadFloat ("Chave");
 variavelInt = LoadInt ("Chave");
 variavelBool = LoadBool ("Chave");
 variavelDouble = LoadDouble ("Chave");
 }



Para salvar Array, praticamente é o mesmo jeito, mas com um requerimento a mais na hora de salvar:

Código:

public Vector3[] checkpoints;

 void Start () {
 SaveVector3Array ("Checkpoints", checkpoints, checkpoints.Length); //Quando a void save for chamada ela precisará
                                                                                  //de 3 informações ("Chave", Array, TamanhoDaArray);
 }

E para carregar os dados, você irá utilizar a mesma forma de quando for carregar uma variável comum:

Código:

public Vector3[] checkpoints;

 void Start () {
 checkpoints = LoadVector3Array ("Checkpoints");
 }

-
Este script necessariamente o suporte é maior quando se trata das Array's, mas para salvar variáveis comuns ela tem um código menor, porém não muito diferente do modo tradicional.

Script de save e load:

Código:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO;
using System;

public class PlayerPrefsEasySave : MonoBehaviour {
 
 public enum ExtensionType {
 PlayerPrefs,
 }
 public ExtensionType extensionType;
 public int sceneID;

 //Save
 public void SaveFloat (string key, float value) {
 if (extensionType == ExtensionType.PlayerPrefs) {
 PlayerPrefs.SetFloat (key + sceneID, value);
 }
 }

 public void SaveInt (string key, int value) {
 if (extensionType == ExtensionType.PlayerPrefs) {
 PlayerPrefs.SetInt (key + sceneID, value);
 }
 }

 public void SaveBool (string key, bool value) {
 if (extensionType == ExtensionType.PlayerPrefs) {
 PlayerPrefs.SetInt(key + sceneID, Convert.ToInt32(value));
 }
 }

 public void SaveString (string key, string text) {
 if (extensionType == ExtensionType.PlayerPrefs) {
 PlayerPrefs.SetString (key + sceneID, text);
 }
 }

 public void SaveDouble (string key, double value) {
 if (extensionType == ExtensionType.PlayerPrefs) {
 string yString = value.ToString ();
 PlayerPrefs.SetString (key + sceneID, yString);
 }
 }

 public void SaveVector3 (string key, Vector3 vector) {
 if (extensionType == ExtensionType.PlayerPrefs) {
 PlayerPrefs.SetFloat (key + sceneID + "x", vector.x);
 PlayerPrefs.SetFloat (key + sceneID + "y", vector.y);
 PlayerPrefs.SetFloat (key + sceneID + "z", vector.z);
 }
 }

 public void SaveVector2 (string key, Vector2 vector) {
 if (extensionType == ExtensionType.PlayerPrefs) {
 PlayerPrefs.SetFloat (key + sceneID + "x", vector.x);
 PlayerPrefs.SetFloat (key + sceneID + "y", vector.y);
 }
 }

 public void SaveQuaternion (string key, Quaternion quaternion) {
 if (extensionType == ExtensionType.PlayerPrefs) {
 PlayerPrefs.SetFloat (key + sceneID + "x", quaternion.x);
 PlayerPrefs.SetFloat (key + sceneID + "y", quaternion.y);
 PlayerPrefs.SetFloat (key + sceneID + "z", quaternion.z);
 PlayerPrefs.SetFloat (key + sceneID + "w", quaternion.w);
 }
 }

 public void SaveFloatArray (string key, float[] array, int length) {
 for (int x = 0; x < array.Length; x++) {
 PlayerPrefs.SetFloat (key + x + "" + sceneID, array[x]);
 PlayerPrefs.SetInt ("LengthFloat" + sceneID, length);
 }
 }

 public void SaveIntArray (string key, int[] array, int length) {
 for (int x = 0; x < array.Length; x++) {
 PlayerPrefs.SetInt (key + x + "" + sceneID, array[x]);
 PlayerPrefs.SetInt ("LengthInt" + sceneID, length);
 }
 }

 public void SaveBoolArray (string key, bool[] array, int length) {
 for (int x = 0; x < array.Length; x++) {
 PlayerPrefs.SetInt(key + x + "" + sceneID, Convert.ToInt32(array[x]));
 PlayerPrefs.SetInt ("LengthBool" + sceneID, length);
 }
 }

 public void SaveStringArray (string key, string[] array, int length) {
 for (int x = 0; x < array.Length; x++) {
 PlayerPrefs.SetString(key + x + "" + sceneID, array[x]);
 PlayerPrefs.SetInt ("LengthString" + sceneID, length);
 }
 }

 public void SaveDoubleArray (string key, double[] array, int length) {
 for (int x = 0; x < array.Length; x++) {
 PlayerPrefs.SetString (key + x + "" + sceneID, array[x].ToString());
 PlayerPrefs.SetInt ("LengthDouble" + sceneID, length);
 }
 }

 public void SaveVector3Array (string key, Vector3[] array, int length) {
 for (int x = 0; x < array.Length; x++) {
 PlayerPrefs.SetFloat (key + x + "x" + sceneID, array[x].x);
 PlayerPrefs.SetFloat (key + x + "y" + sceneID, array[x].y);
 PlayerPrefs.SetFloat (key + x + "z" + sceneID, array[x].z);
 PlayerPrefs.SetInt ("LengthVector3" + sceneID, length);
 }
 }

 public void SaveVector2Array (string key, Vector2[] array, int length) {
 for (int x = 0; x < array.Length; x++) {
 PlayerPrefs.SetFloat (key + x + "x" + sceneID, array[x].x);
 PlayerPrefs.SetFloat (key + x + "y" + sceneID, array[x].y);
 PlayerPrefs.SetInt ("LengthVector2" + sceneID, length);
 }
 }

 public void SaveQuaternionArray (string key, Quaternion[] array, int length) {
 for (int x = 0; x < array.Length; x++) {
 PlayerPrefs.SetFloat (key + x + "x" + sceneID, array[x].x);
 PlayerPrefs.SetFloat (key + x + "y" + sceneID, array[x].y);
 PlayerPrefs.SetFloat (key + x + "z" + sceneID, array[x].z);
 PlayerPrefs.SetFloat (key + x + "w" + sceneID, array[x].w);
 PlayerPrefs.SetInt ("LengthQuaternion" + sceneID, length);
 }
 }

 //Load
 public float LoadFloat (string key) {
 float load = PlayerPrefs.GetFloat (key + sceneID);
 return load;
 }

 public int LoadInt (string key) {
 int load = PlayerPrefs.GetInt (key + sceneID);
 return load;
 }

 public bool LoadBool (string key) {
 bool load = Convert.ToBoolean(PlayerPrefs.GetInt(key + sceneID));
 return load;
 }

 public string LoadString (string key) {
 string text = PlayerPrefs.GetString (key + sceneID);
 return text;
 }

 public double LoadDouble (string key) {
 string yString = PlayerPrefs.GetString (key + sceneID);
 double value = double.Parse (yString, System.Globalization.CultureInfo.InvariantCulture);
 return value;
 }

 public Vector2 LoadVector2 (string key) {
 Vector2 vector = new Vector3 (PlayerPrefs.GetFloat (key + sceneID + "x"), PlayerPrefs.GetFloat (key + sceneID + "y"));
 return vector;
 }

 public Vector3 LoadVector3 (string key) {
 Vector3 vector = new Vector3 (PlayerPrefs.GetFloat (key + sceneID + "x"), PlayerPrefs.GetFloat (key + sceneID + "y"),
 PlayerPrefs.GetFloat (key + sceneID + "z"));
 return vector;
 }

 public Quaternion LoadQuaternion (string key) {
 Quaternion quaternion = new Quaternion (PlayerPrefs.GetFloat (key + sceneID + "x"), PlayerPrefs.GetFloat (key + sceneID + "y"),
 PlayerPrefs.GetFloat (key + sceneID + "z"), PlayerPrefs.GetFloat (key + sceneID + "w"));
 return quaternion;
 }

 public float[] LoadFloatArray (string key) {
 float[] array = new float[PlayerPrefs.GetInt ("LengthFloat" + sceneID)];
 for (int x = 0; x < array.Length; x++) {
 array [x] = PlayerPrefs.GetFloat (key + x + "" + sceneID);
 }
 return array;
 }

 public int[] LoadIntArray (string key) {
 int[] array = new int[PlayerPrefs.GetInt ("LengthInt" + sceneID)];
 for (int x = 0; x < array.Length; x++) {
 array [x] = PlayerPrefs.GetInt (key + x + "" + sceneID);
 }
 return array;
 }

 public bool[] LoadBoolArray (string key) {
 bool[] array = new bool[PlayerPrefs.GetInt ("LengthBool" + sceneID)];
 for (int x = 0; x < array.Length; x++) {
 array [x] = Convert.ToBoolean(PlayerPrefs.GetInt(key + x + "" + sceneID));
 }
 return array;
 }

 public string[] LoadStringArray (string key) {
 string[] array = new string[PlayerPrefs.GetInt ("LengthString" + sceneID)];
 for (int x = 0; x < array.Length; x++) {
 array [x] = PlayerPrefs.GetString (key + x + "" + sceneID);
 }
 return array;
 }

 public double[] LoadDoubleArray (string key) {
 double[] array = new double[PlayerPrefs.GetInt ("LengthDouble" + sceneID)];
 for (int x = 0; x < array.Length; x++) {
 array [x] = double.Parse (PlayerPrefs.GetString (key + x + "" + sceneID), System.Globalization.CultureInfo.InvariantCulture);
 }
 return array;
 }

 public Vector2[] LoadVector2Array (string key) {
 Vector2[] array = new Vector2[PlayerPrefs.GetInt ("LengthVector2" + sceneID)];
 for (int x = 0; x < array.Length; x++) {
 array[x].x = PlayerPrefs.GetFloat (key + x + "x" + sceneID, array[x].x);
 array[x].y = PlayerPrefs.GetFloat (key + x + "y" + sceneID, array[x].y);
 }
 return array;
 }

 public Vector3[] LoadVector3Array (string key) {
 Vector3[] array = new Vector3[PlayerPrefs.GetInt ("LengthVector3" + sceneID)];
 for (int x = 0; x < array.Length; x++) {
 array[x].x = PlayerPrefs.GetFloat (key + x + "x" + sceneID, array[x].x);
 array[x].y = PlayerPrefs.GetFloat (key + x + "y" + sceneID, array[x].y);
 array[x].z = PlayerPrefs.GetFloat (key + x + "z" + sceneID, array[x].z);
 }
 return array;
 }

 public Quaternion[] LoadQuaternionArray (string key) {
 Quaternion[] array = new Quaternion[PlayerPrefs.GetInt ("LengthQuaternion" + sceneID)];
 for (int x = 0; x < array.Length; x++) {
 array[x].x = PlayerPrefs.GetFloat (key + x + "x" + sceneID, array[x].x);
 array[x].y = PlayerPrefs.GetFloat (key + x + "y" + sceneID, array[x].y);
 array[x].z = PlayerPrefs.GetFloat (key + x + "z" + sceneID, array[x].z);
 array[x].w = PlayerPrefs.GetFloat (key + x + "w" + sceneID, array[x].w);
 }
 return array;
 }
}
 

Abaixo tem um script que tem todos os exemplos de como salvar e carregar todos tipos de variáveis:




Qualquer tipo de bug, falha ou erros no código encontrado se possível poste aqui nos comentários para ser corrigido o mais rapido possivel e também qualquer tipo de dúvida. Futuramente pode ser que esse script seja atualizado com novos tipos de extensão para salvar, além do PlayerPrefs. Obrigado pela atenção.

Nuss, que tutorial lindo.

Parece as void's que eu fazia em C++ pra salvar as variáveis no Atmega2560.

Muito útil

MarcosSchultz escreveu:Nuss, que tutorial lindo.

Parece as void's que eu fazia em C++ pra salvar as variáveis no Atmega2560.

Muito útil

Opa vlw.

Show cara! Parabéns ai!

dstaroski escreveu:Show cara! Parabéns ai!

Vlw 

Só uma dica, ao invés de salvar o array dessa forma criando milhares de variáveis dentro do PlayerPrefs, vc pode converter o array numa string usando o conversor da biblioteca System (link abaixo) que vc irá economizar muito espaço dentro do PlayerPrefs.

https://docs.microsoft.com/en-us/dotnet/api/system.convert.tobase64string?view=netframework-4.7.2

dimmuo escreveu:Só uma dica, ao invés de salvar o array dessa forma criando milhares de variáveis dentro do PlayerPrefs, vc pode converter o array numa string usando o conversor da biblioteca System (link abaixo) que vc irá economizar muito espaço dentro do PlayerPrefs.

https://docs.microsoft.com/en-us/dotnet/api/system.convert.tobase64string?view=netframework-4.7.2

Esse método eu não conhecia, vou dar uma olhada e na próxima versão deste script talvez esse método já esteja implementado. obrigado pela sujestão.

tem como salvar GameObject através desses script ai?? e um GameObject com array tb?

lucaspoiob escreveu:tem como salvar GameObject através desses script ai?? e um GameObject com array tb?

pra isso teria que usar json... salvar GameObject com playerPrefs é meio osso.

MarcosSchultz escreveu:

lucaspoiob escreveu:tem como salvar GameObject através desses script ai?? e um GameObject com array tb?

pra isso teria que usar json... salvar GameObject com playerPrefs é meio osso.

Na nova versão do script que eu preparei daria para salvar em várias extensões [PlayerPrefs, Xml, Json, Binary], com isso daria sim para salvar GameObject, porém eu tive um problema com o meu HD e tive que formatar o pc, e infelizmente como eu ando meio ocupado e deixei um pouco de lado esse projeto, e esqueci miseravelmente de fazer um Backup dos scripts e perdi eles, mas eu ainda vou refaze los, só vai demorar um pouco, pois o script já estava com mais de 400 linhas, mas acho que foi bom isso acontecer, pois agora posso otimizar o script e retirar umas 100 linhas.

rafaelllsd escreveu:

MarcosSchultz escreveu:

lucaspoiob escreveu:tem como salvar GameObject através desses script ai?? e um GameObject com array tb?

pra isso teria que usar json... salvar GameObject com playerPrefs é meio osso.

Na nova versão do script que eu preparei daria para salvar em várias extensões [PlayerPrefs, Xml, Json, Binary], com isso daria sim para salvar GameObject, porém eu tive um problema com o meu HD e tive que formatar o pc, e infelizmente como eu ando meio ocupado e deixei um pouco de lado esse projeto, e esqueci miseravelmente de fazer um Backup dos scripts e perdi eles, mas eu ainda vou refaze los, só vai demorar um pouco, pois o script já estava com mais de 400 linhas, mas acho que foi bom isso acontecer, pois agora posso otimizar o script e retirar umas 100 linhas.

hmmm entendi mano, porra que azar tb mano, mas pelo menos agora você vai conseguir fazer com uma performance melhor e menos linhas, boa sorte mano, valeuuu 

Ainda prefiro binary. E olha que já experimentei quase tudo nessa vida.

artplayer escreveu:Ainda prefiro binary. E olha que já experimentei quase tudo nessa vida.

Concordo, testei todos e o que gostei mais foi o binary,  salva e criptografa, ele vai ser o primeiro da lista quando eu começar a refazer o script.

como faz para usar esse script?