Principais trechos de código úteis para desenvolvedores de Unity

Unity, a popular plataforma de desenvolvimento de jogos, permite que os desenvolvedores criem experiências imersivas e interativas em diversas plataformas. Práticas de codificação eficientes podem aumentar significativamente a produtividade e agilizar os processos de desenvolvimento. Aqui estão alguns trechos de código indispensáveis ​​que todo desenvolvedor Unity deve ter em sua caixa de ferramentas:

1. Implementação de padrão Singleton

public class Singleton<T> : MonoBehaviour where T : MonoBehaviour
{
    private static T _instance;

    public static T Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = FindObjectOfType<T>();
                if (_instance == null)
                {
                    GameObject singletonObject = new GameObject();
                    _instance = singletonObject.AddComponent<T>();
                    singletonObject.name = typeof(T).ToString() + " (Singleton)";
                }
            }
            return _instance;
        }
    }

    protected virtual void Awake()
    {
        if (_instance == null)
        {
            _instance = this as T;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
}

2. Pool de objetos para otimização de desempenho

public class ObjectPool : MonoBehaviour
{
    public GameObject prefab;
    public int poolSize = 10;
    private Queue<GameObject> objectPool = new Queue<GameObject>();

    private void Start()
    {
        for (int i = 0; i < poolSize; i++)
        {
            GameObject obj = Instantiate(prefab);
            obj.SetActive(false);
            objectPool.Enqueue(obj);
        }
    }

    public GameObject GetObjectFromPool()
    {
        if (objectPool.Count > 0)
        {
            GameObject obj = objectPool.Dequeue();
            obj.SetActive(true);
            return obj;
        }
        else
        {
            GameObject obj = Instantiate(prefab);
            return obj;
        }
    }

    public void ReturnObjectToPool(GameObject obj)
    {
        obj.SetActive(false);
        objectPool.Enqueue(obj);
    }
}

3. Script de acompanhamento de câmera suave

public class SmoothCameraFollow : MonoBehaviour
{
    public Transform target;
    public float smoothSpeed = 0.125f;
    public Vector3 offset;

    private void LateUpdate()
    {
        if (target != null)
        {
            Vector3 desiredPosition = target.position + offset;
            Vector3 smoothedPosition = Vector3.Lerp(transform.position, desiredPosition, smoothSpeed);
            transform.position = smoothedPosition;

            transform.LookAt(target);
        }
    }
}

4. Corrotina para ações atrasadas

public IEnumerator DelayedAction(float delay, Action action)
{
    yield return new WaitForSeconds(delay);
    action.Invoke();
}

5. Tratamento de entrada com sistema de eventos

public class InputManager : MonoBehaviour
{
    public static event Action<Vector2> OnMoveInput;
    public static event Action OnJumpInput;

    private void Update()
    {
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");

        if (OnMoveInput != null)
            OnMoveInput(new Vector2(horizontal, vertical));

        if (Input.GetButtonDown("Jump"))
        {
            if (OnJumpInput != null)
                OnJumpInput();
        }
    }
}

Conclusão

Esses trechos de código cobrem uma gama de funcionalidades essenciais comumente usadas no desenvolvimento de jogos Unity. Ao aproveitar esses trechos, os desenvolvedores podem acelerar seu fluxo de trabalho, otimizar o desempenho e criar jogos robustos e ricos em recursos com eficiência. Quer você seja um desenvolvedor iniciante ou experiente, ter uma biblioteca de trechos de código úteis pode ser inestimável para enfrentar vários desafios de desenvolvimento de maneira eficaz. Boa codificação!