Ir al contenido principal

Juegos indie y publishers

Una vez un equipo indie ha terminado un juego o está en la fase de desarrollo y tiene claro los datos clave del juego como el modelo de negocio, plataformas, ventana de lanzamiento y un roadmap bien definido es momento de pensar como querréis lanzar su juego . Evidentemente la auto publicación es una opción, pero obliga al equipo a derivar recursos (tiempo, conocimientos y dinero) en entender como se debe lanzar un juego para que este funcione o al menos recuperemos lo invertido. Como desarrollador de juegos indie, conocer el funcionamiento de los publishers es crucial para decidir si trabajar con uno puede ayudarte a lanzar y comercializar tu juego de manera más efectiva. El punto clave para ello es evaluar lo que necesitamos de él (porting, marqueting, localización, etc.), analizar que recoup tendremos (dinero que habrá que devolver al publisher) y con que condiciones. El recoup (o recoupment) es el proceso por el cual un publisher recupera el dinero invertido en un juego antes d

Aplicación base para móviles

En esta entrada del bloc voy a explicar cómo hacer una base para un proyecto móvil que nos sirva para futuros proyectos. En concreto yo utilizo esta base en Unity para hacer juegos móviles para ahorrarme algo de tiempo y centrarme en el juego.


En concreto el proyecto consiste en 3 escenas que definen la pantalla de Splash, el título del juego y el menú principal. Evidentemente esto sólo es una base, en el titulo podemos poner más cosas: efectos, animaciones, etc. Pero esto ya será en una segunda fase. Ahora solo necesitamos una estructura que funcionen bien en dispositivos móviles y que nos cargue el fichero de configuración del juego y actualice las variables globales del proyecto.



Clase de los datos de configuración:
 using System.Collections.Generic;  
 using System;  
 [Serializable]  
 public class PlayerInfo  
 {  
   public int version = 1;  
   public string gameDateFirstTime;  
   public string playDateFirstTime;  
   public int sessionsCount = 0;  
   public string language = "en";  
   public bool soundPlay = true;    
 }  

Variables globales actuales:
 using UnityEngine;  
 public class GlobalInfo : MonoBehaviour  
 {  
   //General Config  
   public static string configFile = "AttilaCfg";    
   public static bool gameFirstTime;  
   public static bool playFirstTime;  
   public static int sessionsCount;  
   public static int gamesCount;  
   public static string language;  
   public static bool soundPlay = true;  
   //Game  
 }  

Carga de datos:
 using UnityEngine;  
 using System.IO;  
 using System;  
 public class LoadConfig : MonoBehaviour {  
   private string configFileName;  
   private string highScoreFileName;  
   private string fileName;  
      // Use this for initialization  
      void Awake ()  
   {  
     //Configuration  
     configFileName = GlobalInfo.configFile;  
     fileName = Path.Combine(Application.persistentDataPath, "data");  
     fileName = Path.Combine(fileName, configFileName + ".txt");  
     if (!File.Exists(fileName))  
     {  
       PlayerInfo saveData = new PlayerInfo();  
       saveData.gameDateFirstTime = DateTime.Now.ToBinary().ToString();  
       saveData.playDateFirstTime = "";  
       //Save data from PlayerInfo to a file named players  
       DataSaver.saveData(saveData, configFileName);  
       GlobalInfo.gameFirstTime = true;  
       GlobalInfo.playFirstTime = true;  
       GlobalInfo.language = saveData.language;  
       GlobalInfo.soundPlay = true;  
       GlobalInfo.sessionsCount = 0;  
       GlobalInfo.gamesCount = 0;  
     } else  
     {  
       PlayerInfo loadedData = DataSaver.loadData<PlayerInfo>(configFileName);  
       if (loadedData == null)  
       {  
         return;  
       }  
       GlobalInfo.gameFirstTime = false;  
       if (loadedData.playDateFirstTime != "")  
       {  
         GlobalInfo.playFirstTime = false;  
       } else  
       {  
         GlobalInfo.playFirstTime = true;  
       }  
       GlobalInfo.language = loadedData.language;  
       GlobalInfo.soundPlay = loadedData.soundPlay;  
       GlobalInfo.sessionsCount = loadedData.sessionsCount;  
       GlobalInfo.gamesCount = 0;  
     }  
   }  
 }  

Salvar, leer y convertir datos en disco:
 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;  
   }  
 }  

La secuencia básica consiste en:
  1. Carga de la escena Splash
  2. Carga de la escena Título
  3. Carga del fichero de configuración
  4. Actualización de las variables globales
  5. Carga la escena del Menú principal

Vídeo completo del proceso:


Para hacer la carga entre escenas utilizo una función más una animación parar crear un efecto Fade entre ellas, tanto en la entrada como en la salida y en la escena del título un slider para cargar la escena del juego en segundo plano para mostrar la evolución en el slider.

Carga asíncrona de escenas:
 using System.Collections;  
 using UnityEngine;  
 using UnityEngine.UI;  
 using UnityEngine.SceneManagement;  
 public class LoadingBar : MonoBehaviour {  
   private bool loadScene = false;  
   public string loadingSceneName;  
   public float waitSecondsPrev;  
   public float waitSecondsPost;  
   public Slider sliderBar;  
   // Use this for initialization  
      void Start ()  
   {  
     sliderBar.gameObject.SetActive(false);  
     Invoke("Loading", waitSecondsPrev);  
   }  
      // Update is called once per frame  
      void Loading()  
   {  
        if(loadScene == false)  
     {  
       loadScene = true;  
       sliderBar.gameObject.SetActive(true);  
       StartCoroutine("LoadNewScene");  
     }  
      }  
   IEnumerator LoadNewScene()  
   {  
     yield return new WaitForSeconds(waitSecondsPost);  
     AsyncOperation async = SceneManager.LoadSceneAsync(loadingSceneName);  
     while (!async.isDone)  
     {  
       float progress = Mathf.Clamp01(async.progress / 0.9f);  
       sliderBar.value = progress;  
       yield return null;  
     }  
   }  
 }  


Comentarios

Entradas populares de este blog

Back to work!

¡Hola! Estoy emocionado de anunciar que he retomado la actividad en mi blog "Jugando Haciendo Juegos" después de una pausa. En esta nueva etapa, el blog se centrará en proporcionar información valiosa desde dentro de la industria de los videojuegos, incluyendo trucos, curiosidades, herramientas, recursos y consejos sobre cómo crear videojuegos desde la comodidad de tu habitación utilizando Unity. El blog ya cuenta con varios artículos útiles que pueden servir como recursos iniciales. Por ejemplo, hay guías detalladas sobre cómo hacer copias de seguridad de tu código de Unity con GitHub, lo que es crucial para la gestión de versiones y el trabajo colaborativo. También encontrarás tutoriales sobre el diseño de interfaces de usuario, el desarrollo de controladores de personajes y cómo crear un PressKit para tu juego. Mi objetivo es compartir conocimientos prácticos y experiencias personales para ayudar tanto a principiantes como a desarrolladores más avanzados a mejorar sus hab

El diseño de la interfaz de usuario

El estudio del diseño de interfaz de usuario en videojuegos es un tema que se ha estudiado en profundidad pero que muchos desarrolladores que empiezan no prestan mucha atención centrando su energía en las mecánicas del juego y especialmente el arte ya que muchas veces el éxito o el fracaso de un juego dependen de ello. Pero más lejos de la realidad la capacidad lúdica de un juego muchas veces también viene determinada por el diseño de la interfaz que hace de dialogo entre el jugador y el juego. Uno de los mejores análisis de las interfaces de usuario en videojuegos lo encontramos en los estudios realizados por Anthony Stonehouse y Marcus Andrews . El diseño de la interfaz de usuario en los juegos difiere de otro diseño de interfaz de usuario porque implica un elemento adicional: la ficción. La ficción involucra un avatar del usuario real, o jugador. El jugador se convierte en un elemento invisible, pero clave de la historia, como un narrador en una novela o película. Esta ficc

Preparando un evento de videojuegos

Participar en un evento de videojuegos con un stand puede ser una oportunidad única para dar a conocer tus juegos, interactuar directamente con tu público objetivo, y generar un gran impacto en la comunidad. En este artículo, exploraremos cómo preparar un stand de 4x2 metros de manera efectiva, maximizar el uso de la cartelería de fondo, y atraer a los visitantes con técnicas sencillas y económicas de marketing. 1. Diseño y uso eficiente de la cartelería de fondo 1.1. La importancia de una lona reutilizable : La lona que utilices para el fondo de tu stand es una de las inversiones más importantes. Una lona de buena calidad y diseño profesional no solo refuerza tu marca, sino que también puede ser reutilizada en futuros eventos, lo que la convierte en una opción sostenible y económica. Asegúrate de que la lona cubra completamente el fondo de tu stand, ya que esto crea un ambiente inmersivo y profesional. 1.2. Elementos esenciales en la lona: En la cartelería de fondo, incluye: El logoti