Prototipo de juegos móviles en Unity 2018 (Parte 2)

En esta segunda parte querría centrarme en aquellos aspectos visuales y no visuales que necesitamos cuando el jugador empieza la partida de nuestro juego. En la primera parte vimos como configurar la interfaz de Unity parar el desarrollo de aplicaciones móviles y hacer un fade IN y un fade OUT para cambiar de escenas desde la pantalla inicial de splash y la escena del título del juego.

A partir de este punto, cuando el jugador está viendo la pantalla del título debemos hacer algunas comprobaciones y procesos para tener la información de nuestro jugador, el juego y las partidas. Además en este punto podríamos, a partir de la configuración activar el sistema de lenguaje de la aplicación para tener en cuenta la localización del jugador y el idioma que usa. 

Escena del titulo del juego:

1. Serializar la información del juego/jugador
2. Cargar/crear fichero JSON de la configuración
3. Conocer el estado de la aplicación
4. Mostrar la versión de la aplicación
5. Activar la localización del juego y su idioma (opcional)
6. Cargar la escena del menú principal del juego o la escena de configuración inicial

Para guardar la información que deseamos guardar del juego crearemos una clase serializada con la estructura de variables, listas, ... que deseamos guardar:

PlayerInfo

 using System.Collections.Generic;  
 using System;  
 [Serializable]  
 public class PlayerInfo  
 {  
   public List<int> ID = new List<int>();  
   public List<int> Amounts = new List<int>();  
   public int life = 0;  
   public float highScore = 0;  
 }  

Una vez tenemos la clase creada debemos comprobar si en el dispositivo móvil tenemos la información almacenada. Cuando cargamos la escena, en el GameObject que hemos creado añadimos el componente LoadConfig que se encargará de comprobar si tenemos el fichero almacenado y en caso contrario lo creará con los valores por defecto que necesitemos.

LoadConfig

 using UnityEngine;  
 using System.IO;  
 public class LoadConfig : MonoBehaviour {  
   public string configFileName;  
   private string fileName;  
      // Use this for initialization  
      void Awake ()  
   {  
     fileName = Path.Combine(Application.persistentDataPath, "data");  
     fileName = Path.Combine(fileName, configFileName + ".txt");  
     if (!File.Exists(fileName))  
     {  
       PlayerInfo saveData = new PlayerInfo();  
       saveData.life = 100;  
       saveData.highScore = 0;  
       //Save data from PlayerInfo to a file named players  
       DataSaver.saveData(saveData, configFileName);  
       GlobalInfo.gameFirstTime = true;  
     } else  
     {  
       PlayerInfo loadedData = DataSaver.loadData<PlayerInfo>(configFileName);  
       if (loadedData == null)  
       {  
         return;  
       }  
       //Display loaded Data  
       Debug.Log("Life: " + loadedData.life);  
       Debug.Log("High Score: " + loadedData.highScore);  
       for (int i = 0; i < loadedData.ID.Count; i++)  
       {  
         Debug.Log("ID: " + loadedData.ID[i]);  
       }  
       for (int i = 0; i < loadedData.Amounts.Count; i++)  
       {  
         Debug.Log("Amounts: " + loadedData.Amounts[i]);  
       }  
       GlobalInfo.gameFirstTime = false;  
     }  
   }  
 }  

Esta clase tiene como variables publicas el nombre del archivo que deseamos poner al fichero de configuración (sin extensión). Por defecto la rutina añade la extensión .txt al fichero, que podemos cambiar si lo deseamos. Además nos mostrar en la consola la información cargada para comprobar el correcto almacenaje de los datos.

Todo ello es posible gracias a la clase DataServer que es la encargada de hacer el trabajo de conversión entre formatos.

DataServer

 using UnityEngine;  
 using System;  
 using System.IO;  
 using System.Text;  
 public class DataSaver  
 {  
   //Save Data  
   public static void saveData<T>(T dataToSave, string dataFileName)  
   {  
     string tempPath = Path.Combine(Application.persistentDataPath, "data");  
     tempPath = Path.Combine(tempPath, dataFileName + ".txt");  
     //Convert To Json then to bytes  
     string jsonData = JsonUtility.ToJson(dataToSave, true);  
     byte[] jsonByte = Encoding.ASCII.GetBytes(jsonData);  
     //Create Directory if it does not exist  
     if (!Directory.Exists(Path.GetDirectoryName(tempPath)))  
     {  
       Directory.CreateDirectory(Path.GetDirectoryName(tempPath));  
     }  
     try  
     {  
       File.WriteAllBytes(tempPath, jsonByte);  
       Debug.Log("Saved Data to: " + tempPath.Replace("/", "\\"));  
     }  
     catch (Exception e)  
     {  
       Debug.LogWarning("Failed To PlayerInfo Data to: " + tempPath.Replace("/", "\\"));  
       Debug.LogWarning("Error: " + e.Message);  
     }  
   }  
   //Load Data  
   public static T loadData<T>(string dataFileName)  
   {  
     string tempPath = Path.Combine(Application.persistentDataPath, "data");  
     tempPath = Path.Combine(tempPath, dataFileName + ".txt");  
     //Exit if Directory or File does not exist  
     if (!Directory.Exists(Path.GetDirectoryName(tempPath)))  
     {  
       Debug.LogWarning("Directory does not exist");  
       return default(T);  
     }  
     if (!File.Exists(tempPath))  
     {  
       Debug.Log("File does not exist");  
       return default(T);  
     }  
     //Load saved Json  
     byte[] jsonByte = null;  
     try  
     {  
       jsonByte = File.ReadAllBytes(tempPath);  
       Debug.Log("Loaded Data from: " + tempPath.Replace("/", "\\"));  
     }  
     catch (Exception e)  
     {  
       Debug.LogWarning("Failed To Load Data from: " + tempPath.Replace("/", "\\"));  
       Debug.LogWarning("Error: " + e.Message);  
     }  
     //Convert to json string  
     string jsonData = Encoding.ASCII.GetString(jsonByte);  
     //Convert to Object  
     object resultValue = JsonUtility.FromJson<T>(jsonData);  
     return (T)Convert.ChangeType(resultValue, typeof(T));  
   }  
   public static bool deleteData(string dataFileName)  
   {  
     bool success = false;  
     //Load Data  
     string tempPath = Path.Combine(Application.persistentDataPath, "data");  
     tempPath = Path.Combine(tempPath, dataFileName + ".txt");  
     //Exit if Directory or File does not exist  
     if (!Directory.Exists(Path.GetDirectoryName(tempPath)))  
     {  
       Debug.LogWarning("Directory does not exist");  
       return false;  
     }  
     if (!File.Exists(tempPath))  
     {  
       Debug.Log("File does not exist");  
       return false;  
     }  
     try  
     {  
       File.Delete(tempPath);  
       Debug.Log("Data deleted from: " + tempPath.Replace("/", "\\"));  
       success = true;  
     }  
     catch (Exception e)  
     {  
       Debug.LogWarning("Failed To Delete Data: " + e.Message);  
     }  
     return success;  
   }  
 }  

Por lo que se refiere a la información tenemos una ultima clase que se encarga de mostrar la información de la versión en la pantalla a través de la variable pública de la clase.

AppVersion

 using UnityEngine;  
 using UnityEngine.UI;  
 public class AppVersion : MonoBehaviour {  
   public Text TextVersion;   
      // Use this for initialization  
      void Start ()  
   {  
     TextVersion.text = "Version: " + Application.version;  
   }  
 }  

Ejemplo:

Pantalla Splash A través de un fade pasamos a la pantalla de título.	Pantalla de título Carga de la configuración.  La versión del juego.  Establece el punto de estado de la aplicación. Saltamos al menú principal con una barra de progreso.

Cuando saltamos a la siguiente pantalla a través de una variable global sabremos si es la primera vez que ejecutamos la aplicación o no. Algunas veces nos puede interesar que en el menú principal podamos forzar una pantalla de configuración para establecer los parámetros iniciales del juego (idioma, nombre, país, ...).

 using UnityEngine;  
 public class GlobalInfo : MonoBehaviour  
 {  
   public static bool gameFirstTime;  
 }