La importancia de optimizar el código en videojuegos 🎮

🔧🎮 ¡Optimizar el código para crear experiencias inolvidables! 🎮🔧

En el mundo del desarrollo de videojuegos, la búsqueda de la optimización es la clave para desbloquear todo el potencial de nuestras creaciones. Como desarrolladores, nos esforzamos constantemente por afinar nuestro código, creando juegos que funcionen sin problemas, sumerjan a los jugadores y brinden experiencias inolvidables. He aquí por qué la optimización del código es crucial:

1️⃣ Jugabilidad perfecta

Al optimizar nuestro código, nos debemos asegurar de que los juegos funcionen sin problemas, ofreciendo a los jugadores una experiencia de juego fluida y envolvente. Velocidades de fotogramas suaves, controles receptivos y tiempos de carga mínimos contribuyen muy positivamente a lograr esta jugabilidad perfecta.

Un pequeño ejemplo sobre como bloquear el framerate de un videojuego a 60fps con Unity:

using UnityEngine;

public class GameLoop : MonoBehaviour
{
    private float targetFrameTime = 0.0167f; // Target frame time of 60 FPS

    private void Awake()
    {
        Application.targetFrameRate = 60; // Set the target frame rate to 60 FPS
    }

    private void Update()
    {
        float deltaTime = Time.unscaledDeltaTime;

        // Limit the frame rate to achieve consistent frame timing
        if (deltaTime < targetFrameTime)
        {
            float delay = targetFrameTime - deltaTime;
            System.Threading.Thread.Sleep((int)(delay * 1000));
        }

        // Perform game logic and update game objects here
        // ...

        // Render game visuals and handle user input here
        // ...
    }
}

2️⃣ Compatibilidad entre plataformas

Los videojuegos se disfrutan en una amplia gama de plataformas, desde consolas hasta PC y dispositivos móviles. La optimización del código nos permite aprovechar al máximo las capacidades de cada plataforma, maximizando el rendimiento y asegurando que nuestros juegos puedan llegar y deleitar a los jugadores en varios dispositivos.

Un pequeño ejemplo sobre como crear código específico para distintas plataformas con Unity:

using UnityEngine;

public class PlatformCompatibility : MonoBehaviour
{
    private void Start()
    {
        // Check the current platform and execute platform-specific code
        #if UNITY_ANDROID
            Debug.Log("Running on Android");
            // Add Android-specific code here
        #elif UNITY_IOS
            Debug.Log("Running on iOS");
            // Add iOS-specific code here
        #elif UNITY_STANDALONE_WIN
            Debug.Log("Running on Windows");
            // Add Windows-specific code here
        #elif UNITY_STANDALONE_OSX
            Debug.Log("Running on macOS");
            // Add macOS-specific code here
        #else
            Debug.Log("Running on an unsupported platform");
        #endif
    }
}

3️⃣ Gestión eficiente de recursos

Cada byte de memoria y cada ciclo de CPU cuenta en el mundo de los videojuegos. El código optimizado minimiza el consumo de recursos, lo que permite una asignación de memoria eficiente, una representación más rápida y un juego más fluido. Este enfoque garantiza que los jugadores puedan sumergirse por completo en el mundo de los videojuegos sin interrupciones ni cuellos de botella en el rendimiento.

De nuevo te dejo por aquí un pequeño ejemplo sobre como crear un pool de objetos con unity para optimizar los recursos y evitar tener que crear/destruir posibles assets que se usan muy comúnmente:

using UnityEngine;

using System.Collections.Generic;

public class ObjectPool : MonoBehaviour
{
    public GameObject prefab;
    public int poolSize = 10;

    private List<GameObject> objectPool;

    private void Start()
    {
        // Create the object pool
        objectPool = new List<GameObject>();

        for (int i = 0; i < poolSize; i++)
        {
            GameObject newObj = Instantiate(prefab);
            newObj.SetActive(false);
            objectPool.Add(newObj);
        }
    }

    public GameObject GetObjectFromPool()
    {
        // Find and return an inactive object from the pool
        foreach (GameObject obj in objectPool)
        {
            if (!obj.activeInHierarchy)
            {
                obj.SetActive(true);
                return obj;
            }
        }

        // If no inactive objects are found, create a new one
        GameObject newObj = Instantiate(prefab);
        objectPool.Add(newObj);
        return newObj;
    }

    public void ReturnObjectToPool(GameObject obj)
    {
        // Reset and deactivate the object, returning it to the pool
        obj.SetActive(false);
        obj.transform.position = Vector3.zero; // Reset any necessary properties
    }
}

4️⃣ Carga y transmisión más rápidas

Las técnicas de optimización, como el data streaming y la carga de assets, pueden reducir significativamente los tiempos de carga, mejorando la experiencia general del jugador. Al organizar y optimizar cuidadosamente nuestro código, creamos una transición fluida entre los niveles, entornos y assets del juego, lo que mantiene a los jugadores comprometidos e inmersos en la acción.

Aquí van dos ejemplos con Unity, el primero sobre la carga asíncrona de assets y el segundo sobre el data streaming:

using UnityEngine;

public class AssetLoader : MonoBehaviour
{
    public string assetPath = "Assets/MyAsset.asset";

    private void Start()
    {
        StartCoroutine(LoadAssetAsync(assetPath));
    }

    private System.Collections.IEnumerator LoadAssetAsync(string path)
    {
        AssetBundleCreateRequest bundleLoadRequest = AssetBundle.LoadFromFileAsync(path);
        yield return bundleLoadRequest;

        AssetBundle assetBundle = bundleLoadRequest.assetBundle;

        if (assetBundle == null)
        {
            Debug.LogError("Failed to load Asset Bundle from path: " + path);
            yield break;
        }

        AssetBundleRequest assetLoadRequest = assetBundle.LoadAssetAsync<GameObject>("MyGameObject");
        yield return assetLoadRequest;

        GameObject loadedAsset = assetLoadRequest.asset as GameObject;

        if (loadedAsset != null)
        {
            Instantiate(loadedAsset, transform.position, Quaternion.identity);
        }
        else
        {
            Debug.LogError("Failed to load asset: " + path);
        }

        // Unload the asset bundle to free up memory
        assetBundle.Unload(false);
    }
}

using UnityEngine;

public class DataStreamer : MonoBehaviour
{
    public string dataFilePath = "StreamingAssets/Data.txt";

    private void Start()
    {
        StartCoroutine(StreamData());
    }

    private System.Collections.IEnumerator StreamData()
    {
        string fullPath = Application.streamingAssetsPath + "/" + dataFilePath;

        using (var reader = new System.IO.StreamReader(fullPath))
        {
            string line;
            while ((line = reader.ReadLine()) != null)
            {
                // Process each line of data here
                Debug.Log(line);

                // Wait for a frame before processing the next line
                yield return null;
            }
        }
    }
}

5️⃣ Escalabilidad y preparación para el futuro

El código optimizado allana el camino para la escalabilidad y futuras mejoras. Nos permite agregar nuevas funciones de manera eficiente, expandir los mundos de los juegos y adaptar las tecnologías emergentes. Al construir una base sólida de código optimizado, nos posicionamos para adaptarnos y evolucionar a medida que avanza el panorama de los juegos.

Crear un ejemplo sobre este apartado es complicado, ya que cada proyecto es diferente y principalmente importa la escala del mismo y hacia donde puede crecer. Por ejemplo en un juego de carreras de coches podría aumentar la envergadura del proyecto añadiendo más cantidad de coches jugables, opciones multijugador, modalidades de carreras diferentes... Pero sería muy extraño que pasara a ser un juego de estrategia medieval.

Igualmente, aquí va un pequeño ejemplo de código en Unity para ver como podría ser necesario añadir futuras funcionalidades al control de movimiento de un personaje, siempre es importante intentar agrupar en procedimientos y funciones el código para poder escalarlo o reutilizarlo a futuro, a la vez de que es más legible para cualquier programador:

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    // Adjustable properties for future-proofing
    [SerializeField] private float moveSpeed = 5f;
    [SerializeField] private float jumpForce = 10f;
    [SerializeField] private int maxHealth = 100;

    private Rigidbody2D rb;
    private Animator anim;
    private int currentHealth;

    private void Awake()
    {
        rb = GetComponent<Rigidbody2D>();
        anim = GetComponent<Animator>();

        currentHealth = maxHealth;
    }

    private void Update()
    {
        // Handle player input for movement and jumping
        float horizontalInput = Input.GetAxis("Horizontal");
        rb.velocity = new Vector2(horizontalInput * moveSpeed, rb.velocity.y);

        if (Input.GetButtonDown("Jump"))
        {
            Jump();
        }

        // Check for additional future-proofing features or enhancements
        // ...
    }

    private void Jump()
    {
        // Add vertical force to the player for jumping
        rb.AddForce(new Vector2(0f, jumpForce), ForceMode2D.Impulse);
    }

    public void TakeDamage(int damageAmount)
    {
        // Reduce player's health by the specified damage amount
        currentHealth -= damageAmount;

        // Check if the player is dead
        if (currentHealth <= 0)
        {
            Die();
        }
    }

    private void Die()
    {
        // Perform actions when the player dies, such as showing game over screen or resetting the level
        // ...

        // Consider additional future-proofing features or enhancements
        // ...
    }
}

Conclusión

La optimización del código para el desarrollo de videojuegos es tanto un arte como una ciencia. Requiere una atención meticulosa a los detalles, pruebas continuas y la voluntad de explorar nuevas técnicas y tecnologías.