¿Por qué Unity para Juegos 2D?

Unity se ha consolidado como una de las herramientas más versátiles para desarrollo de juegos 2D, especialmente para desarrolladores independientes y estudios pequeños. Su ecosistema robusto y su curva de aprendizaje accesible lo convierten en la elección perfecta para:

  • Publicación multiplataforma: PC, móviles, consolas y web desde un solo proyecto
  • Asset Store extenso: Miles de recursos, scripts y herramientas
  • Comunidad activa: Amplio soporte y documentación en español
  • Pipeline 2D optimizado: Herramientas específicas para desarrollo 2D
  • Visual Scripting: Opción sin código para principiantes
  • C# moderno: Lenguaje potente y well-documented

Configuración del Entorno Unity 2D

Instalación y Configuración Inicial

Para empezar con Unity 2D necesitas configurar correctamente tu entorno de desarrollo:

Unity Hub y Editor

  1. Descarga Unity Hub desde el sitio oficial
  2. Instala Unity LTS (versión 2022.3 LTS recomendada)
  3. Incluye módulos para tus plataformas objetivo (Android, iOS, WebGL)
  4. Instala Visual Studio o Visual Studio Code como IDE

Creando tu Primer Proyecto 2D

⚙️ Configuración Recomendada para Proyectos 2D ▼ Expandir 
// Configuración recomendada para proyectos 2D
// En Project Settings > Graphics:
// - Scriptable Render Pipeline: Universal RP (URP)
// - Color Space: Linear (para mejor calidad visual)
// - Texture Quality: Full Res

// En Project Settings > Physics 2D:
// - Gravity: (0, -9.81) para física realista
// - Velocity Threshold: 1
// - Sleep Threshold: 0.005

Estructura del Proyecto

Organiza tu proyecto desde el inicio para mantener un workflow eficiente:

📁 Estructura de Carpetas Recomendada ▼ Expandir 
// Estructura de carpetas recomendada:
Assets/
├── Art/
│   ├── Sprites/
│   ├── Animations/
│   ├── Materials/
│   └── UI/
├── Audio/
│   ├── Music/
│   ├── SFX/
│   └── Mixers/
├── Scripts/
│   ├── Player/
│   ├── Enemies/
│   ├── Managers/
│   └── UI/
├── Prefabs/
├── Scenes/
└── Resources/

Fundamentos del Desarrollo 2D en Unity

Sistema de Sprites y Texturas

Qué hace: Gestiona las imágenes 2D (sprites) que componen los elementos visuales de tu juego, desde personajes hasta fondos y UI.

Configuración de Sprites

🎨 SpriteManager.cs - Sistema Dinámico de Sprites ▼ Expandir 
// SpriteManager.cs - Sistema para gestionar sprites dinámicamente
using UnityEngine;

public class SpriteManager : MonoBehaviour
{
    [Header("Sprite Configuration")]
    public SpriteRenderer spriteRenderer;
    public Sprite[] animationFrames;
    
    [Header("Animation Settings")]
    public float frameRate = 12f;
    public bool isLooping = true;
    
    private int currentFrame;
    private float frameTimer;
    
    void Start()
    {
        if (spriteRenderer == null)
            spriteRenderer = GetComponent();
            
        // Configurar sprite inicial
        if (animationFrames.Length > 0)
            spriteRenderer.sprite = animationFrames[0];
    }
    
    void Update()
    {
        if (animationFrames.Length <= 1) return;
        
        AnimateSprite();
    }
    
    void AnimateSprite()
    {
        frameTimer += Time.deltaTime;
        
        if (frameTimer >= 1f / frameRate)
        {
            frameTimer = 0f;
            currentFrame++;
            
            if (currentFrame >= animationFrames.Length)
            {
                if (isLooping)
                    currentFrame = 0;
                else
                    currentFrame = animationFrames.Length - 1;
            }
            
            spriteRenderer.sprite = animationFrames[currentFrame];
        }
    }
    
    public void SetAnimation(Sprite[] newFrames, float newFrameRate = 12f)
    {
        animationFrames = newFrames;
        frameRate = newFrameRate;
        currentFrame = 0;
        frameTimer = 0f;
        
        if (animationFrames.Length > 0)
            spriteRenderer.sprite = animationFrames[0];
    }
}

Configuración de Import Settings

📋 Configuración Recomendada para Sprites ▼ Expandir 
// Configuración recomendada para sprites:
// Texture Type: Sprite (2D and UI)
// Sprite Mode: Single (para sprites individuales) o Multiple (para spritesheets)
// Pixels Per Unit: 100 (ajustar según resolución deseada)
// Filter Mode: Point (pixel art) o Bilinear (art suave)
// Compression: None o Low Quality (para mejor calidad)
// Generate Mip Maps: Desactivado para 2D

Sistema de Movimiento 2D

Qué hace: Controla el movimiento de personajes usando física 2D de Unity, incluyendo detección de input, física y animaciones de movimiento.

🎮 PlayerController2D.cs - Movimiento Completo del Personaje ▼ Expandir 
using UnityEngine;

public class PlayerController2D : MonoBehaviour
{
    [Header("Movement Settings")]
    public float moveSpeed = 5f;
    public float jumpForce = 10f;
    public LayerMask groundLayer;
    
    [Header("Ground Detection")]
    public Transform groundCheck;
    public float groundCheckRadius = 0.2f;
    
    [Header("Components")]
    private Rigidbody2D rb;
    private SpriteRenderer spriteRenderer;
    private Animator animator;
    
    // Movement variables
    private float horizontalInput;
    private bool isGrounded;
    private bool facingRight = true;
    
    void Start()
    {
        rb = GetComponent();
        spriteRenderer = GetComponent();
        animator = GetComponent();
        
        // Configurar físicas 2D
        rb.freezeRotation = true;
        rb.collisionDetectionMode = CollisionDetectionMode2D.Continuous;
    }
    
    void Update()
    {
        HandleInput();
        CheckGrounded();
        UpdateAnimations();
    }
    
    void FixedUpdate()
    {
        MovePlayer();
    }
    
    void HandleInput()
    {
        horizontalInput = Input.GetAxisRaw("Horizontal");
        
        if (Input.GetKeyDown(KeyCode.Space) && isGrounded)
        {
            Jump();
        }
    }
    
    void MovePlayer()
    {
        // Movimiento horizontal
        rb.velocity = new Vector2(horizontalInput * moveSpeed, rb.velocity.y);
        
        // Flip del sprite según dirección
        if (horizontalInput > 0 && !facingRight)
            Flip();
        else if (horizontalInput < 0 && facingRight)
            Flip();
    }
    
    void Jump()
    {
        rb.velocity = new Vector2(rb.velocity.x, jumpForce);
    }
    
    void CheckGrounded()
    {
        isGrounded = Physics2D.OverlapCircle(groundCheck.position, groundCheckRadius, groundLayer);
    }
    
    void Flip()
    {
        facingRight = !facingRight;
        spriteRenderer.flipX = !facingRight;
    }
    
    void UpdateAnimations()
    {
        if (animator != null)
        {
            animator.SetFloat("Speed", Mathf.Abs(horizontalInput));
            animator.SetBool("IsGrounded", isGrounded);
            animator.SetFloat("VelocityY", rb.velocity.y);
        }
    }
    
    void OnDrawGizmosSelected()
    {
        // Visualizar área de detección de suelo
        if (groundCheck != null)
        {
            Gizmos.color = isGrounded ? Color.green : Color.red;
            Gizmos.DrawWireSphere(groundCheck.position, groundCheckRadius);
        }
    }
}

Sistema de Animación 2D

Qué hace: Gestiona transiciones fluidas entre diferentes estados de animación (idle, walk, jump, attack) usando el Animator Controller de Unity.

Animator Controller Setup

🎬 AnimationController.cs - Control Avanzado de Animaciones ▼ Expandir 
// AnimationController.cs - Control avanzado de animaciones
using UnityEngine;

public class AnimationController : MonoBehaviour
{
    [Header("Animation References")]
    public Animator animator;
    
    [Header("Animation Clips")]
    public AnimationClip idleClip;
    public AnimationClip walkClip;
    public AnimationClip jumpClip;
    public AnimationClip fallClip;
    
    // Hash IDs para optimización
    private int speedHash;
    private int groundedHash;
    private int velocityYHash;
    private int attackHash;
    
    void Start()
    {
        if (animator == null)
            animator = GetComponent();
            
        // Calcular hash IDs una vez para mejor performance
        speedHash = Animator.StringToHash("Speed");
        groundedHash = Animator.StringToHash("IsGrounded");
        velocityYHash = Animator.StringToHash("VelocityY");
        attackHash = Animator.StringToHash("Attack");
    }
    
    public void SetSpeed(float speed)
    {
        animator.SetFloat(speedHash, speed);
    }
    
    public void SetGrounded(bool grounded)
    {
        animator.SetBool(groundedHash, grounded);
    }
    
    public void SetVelocityY(float velocityY)
    {
        animator.SetFloat(velocityYHash, velocityY);
    }
    
    public void TriggerAttack()
    {
        animator.SetTrigger(attackHash);
    }
    
    // Eventos de animación (llamados desde Animation Events)
    public void OnAttackStart()
    {
        Debug.Log("Attack animation started");
    }
    
    public void OnAttackEnd()
    {
        Debug.Log("Attack animation ended");
    }
}

Sistemas Avanzados para Juegos 2D

Sistema de Cámara 2D Inteligente

Qué hace: Sigue al jugador de forma suave con límites configurables, shake effects y transiciones entre diferentes áreas del juego.

📹 CameraController2D.cs - Cámara Inteligente con Shake ▼ Expandir 
using UnityEngine;
using Cinemachine;

public class CameraController2D : MonoBehaviour
{
    [Header("Follow Settings")]
    public Transform target;
    public float followSpeed = 2f;
    public Vector2 offset = Vector2.zero;
    
    [Header("Bounds")]
    public bool useBounds = true;
    public Bounds cameraBounds;
    
    [Header("Smooth Damping")]
    public float dampingX = 1f;
    public float dampingY = 1f;
    
    [Header("Camera Shake")]
    public float shakeIntensity = 0f;
    public float shakeDuration = 0f;
    
    private Camera cam;
    private Vector2 velocity;
    private Vector3 originalPosition;
    private float shakeTimer;
    
    void Start()
    {
        cam = GetComponent();
        originalPosition = transform.position;
    }
    
    void LateUpdate()
    {
        if (target == null) return;
        
        FollowTarget();
        ApplyCameraBounds();
        ApplyCameraShake();
    }
    
    void FollowTarget()
    {
        Vector2 targetPosition = (Vector2)target.position + offset;
        Vector2 currentPosition = transform.position;
        
        // Smooth damping para movimiento suave
        Vector2 newPosition = Vector2.SmoothDamp(
            currentPosition, 
            targetPosition, 
            ref velocity, 
            1f / followSpeed
        );
        
        transform.position = new Vector3(newPosition.x, newPosition.y, transform.position.z);
    }
    
    void ApplyCameraBounds()
    {
        if (!useBounds) return;
        
        Vector3 pos = transform.position;
        float camHeight = cam.orthographicSize;
        float camWidth = camHeight * cam.aspect;
        
        pos.x = Mathf.Clamp(pos.x, cameraBounds.min.x + camWidth, cameraBounds.max.x - camWidth);
        pos.y = Mathf.Clamp(pos.y, cameraBounds.min.y + camHeight, cameraBounds.max.y - camHeight);
        
        transform.position = pos;
    }
    
    void ApplyCameraShake()
    {
        if (shakeTimer > 0)
        {
            Vector2 shakeOffset = Random.insideUnitCircle * shakeIntensity;
            transform.position = originalPosition + (Vector3)shakeOffset;
            
            shakeTimer -= Time.deltaTime;
        }
        else
        {
            shakeIntensity = 0f;
            originalPosition = transform.position;
        }
    }
    
    public void Shake(float intensity, float duration)
    {
        shakeIntensity = intensity;
        shakeDuration = duration;
        shakeTimer = duration;
        originalPosition = transform.position;
    }
    
    void OnDrawGizmos()
    {
        if (useBounds)
        {
            Gizmos.color = Color.green;
            Gizmos.DrawWireCube(cameraBounds.center, cameraBounds.size);
        }
    }
}

Sistema de Colisiones y Triggers

Qué hace: Maneja interacciones entre objetos, detección de enemigos, coleccionables y zonas especiales usando el sistema de Physics2D de Unity.

using UnityEngine;
using UnityEngine.Events;

public class TriggerZone2D : MonoBehaviour
{
    [Header("Trigger Settings")]
    public LayerMask triggerLayers = -1;
    public bool triggerOnce = false;
    public bool requireTag = false;
    public string requiredTag = "Player";
    
    [Header("Events")]
    public UnityEvent OnEnterTrigger;
    public UnityEvent OnExitTrigger;
    public UnityEvent OnStayTrigger;
    
    [Header("Audio")]
    public AudioClip enterSound;
    public AudioClip exitSound;
    
    private bool hasTriggered = false;
    private AudioSource audioSource;
    
    void Start()
    {
        audioSource = GetComponent();
        
        // Asegurar que el collider sea trigger
        Collider2D col = GetComponent();
        if (col != null)
            col.isTrigger = true;
    }
    
    void OnTriggerEnter2D(Collider2D other)
    {
        if (!CanTrigger(other)) return;
        
        if (triggerOnce && hasTriggered) return;
        
        hasTriggered = true;
        
        OnEnterTrigger?.Invoke();
        PlaySound(enterSound);
        
        Debug.Log($"Trigger entered by: {other.name}");
    }
    
    void OnTriggerExit2D(Collider2D other)
    {
        if (!CanTrigger(other)) return;
        
        OnExitTrigger?.Invoke();
        PlaySound(exitSound);
        
        Debug.Log($"Trigger exited by: {other.name}");
    }
    
    void OnTriggerStay2D(Collider2D other)
    {
        if (!CanTrigger(other)) return;
        
        OnStayTrigger?.Invoke();
    }
    
    bool CanTrigger(Collider2D other)
    {
        // Verificar layer
        if ((triggerLayers.value & (1 << other.gameObject.layer)) == 0)
            return false;
        
        // Verificar tag si es requerido
        if (requireTag && !other.CompareTag(requiredTag))
            return false;
        
        return true;
    }
    
    void PlaySound(AudioClip clip)
    {
        if (audioSource != null && clip != null)
        {
            audioSource.PlayOneShot(clip);
        }
    }
    
    public void ResetTrigger()
    {
        hasTriggered = false;
    }
}

Sistema de UI Responsiva

Qué hace: Crea interfaces de usuario que se adaptan automáticamente a diferentes resoluciones y aspect ratios, esencial para publicación multiplataforma.

using UnityEngine;
using UnityEngine.UI;
using TMPro;

public class ResponsiveUI : MonoBehaviour
{
    [Header("Screen Adaptation")]
    public CanvasScaler canvasScaler;
    public bool adaptToScreenSize = true;
    
    [Header("Safe Area (Mobile)")]
    public RectTransform safeAreaRect;
    public bool applySafeArea = true;
    
    [Header("Dynamic Text Sizing")]
    public TextMeshProUGUI[] responsiveTexts;
    public float baseTextSize = 24f;
    public float minTextSize = 16f;
    public float maxTextSize = 48f;
    
    private Vector2 lastScreenSize;
    private Rect lastSafeArea;
    
    void Start()
    {
        SetupCanvasScaler();
        ApplySafeArea();
        AdjustTextSizes();
        
        lastScreenSize = new Vector2(Screen.width, Screen.height);
        lastSafeArea = Screen.safeArea;
    }
    
    void Update()
    {
        // Detectar cambios en resolución o safe area
        Vector2 currentScreenSize = new Vector2(Screen.width, Screen.height);
        Rect currentSafeArea = Screen.safeArea;
        
        if (currentScreenSize != lastScreenSize || currentSafeArea != lastSafeArea)
        {
            ApplySafeArea();
            AdjustTextSizes();
            
            lastScreenSize = currentScreenSize;
            lastSafeArea = currentSafeArea;
        }
    }
    
    void SetupCanvasScaler()
    {
        if (canvasScaler == null)
            canvasScaler = GetComponent();
        
        if (adaptToScreenSize && canvasScaler != null)
        {
            canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
            canvasScaler.referenceResolution = new Vector2(1920, 1080);
            canvasScaler.screenMatchMode = CanvasScaler.ScreenMatchMode.MatchWidthOrHeight;
            canvasScaler.matchWidthOrHeight = 0.5f; // Balance entre width y height
        }
    }
    
    void ApplySafeArea()
    {
        if (!applySafeArea || safeAreaRect == null) return;
        
        Rect safeArea = Screen.safeArea;
        Vector2 screenSize = new Vector2(Screen.width, Screen.height);
        
        // Convertir safe area a coordenadas relativas
        Vector2 anchorMin = safeArea.position;
        Vector2 anchorMax = safeArea.position + safeArea.size;
        
        anchorMin.x /= screenSize.x;
        anchorMin.y /= screenSize.y;
        anchorMax.x /= screenSize.x;
        anchorMax.y /= screenSize.y;
        
        safeAreaRect.anchorMin = anchorMin;
        safeAreaRect.anchorMax = anchorMax;
    }
    
    void AdjustTextSizes()
    {
        if (responsiveTexts == null) return;
        
        float scaleFactor = GetScreenScaleFactor();
        
        foreach (var text in responsiveTexts)
        {
            if (text != null)
            {
                float newSize = baseTextSize * scaleFactor;
                newSize = Mathf.Clamp(newSize, minTextSize, maxTextSize);
                text.fontSize = newSize;
            }
        }
    }
    
    float GetScreenScaleFactor()
    {
        // Calcular factor de escala basado en resolución
        float referenceWidth = 1920f;
        float referenceHeight = 1080f;
        
        float scaleWidth = Screen.width / referenceWidth;
        float scaleHeight = Screen.height / referenceHeight;
        
        return Mathf.Lerp(scaleWidth, scaleHeight, 0.5f);
    }
}

Optimización y Performance

Object Pooling para Performance

Concepto: Reutiliza objetos en lugar de crearlos y destruirlos constantemente, eliminando garbage collection y mejorando el framerate.

Qué hace: Gestiona pools de objetos reutilizables como proyectiles, efectos de partículas y enemigos para mantener performance óptima.

using System.Collections.Generic;
using UnityEngine;

public class ObjectPool : MonoBehaviour
{
    [System.Serializable]
    public class Pool
    {
        public string tag;
        public GameObject prefab;
        public int size;
    }
    
    [Header("Pool Configuration")]
    public List pools;
    
    private Dictionary> poolDictionary;
    
    void Start()
    {
        poolDictionary = new Dictionary>();
        
        foreach (Pool pool in pools)
        {
            Queue objectPool = new Queue();
            
            for (int i = 0; i < pool.size; i++)
            {
                GameObject obj = Instantiate(pool.prefab, transform);
                obj.SetActive(false);
                objectPool.Enqueue(obj);
            }
            
            poolDictionary.Add(pool.tag, objectPool);
        }
    }
    
    public GameObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation)
    {
        if (!poolDictionary.ContainsKey(tag))
        {
            Debug.LogWarning($"Pool with tag {tag} doesn't exist.");
            return null;
        }
        
        if (poolDictionary[tag].Count == 0)
        {
            Debug.LogWarning($"Pool {tag} is empty! Consider increasing pool size.");
            return null;
        }
        
        GameObject objectToSpawn = poolDictionary[tag].Dequeue();
        
        objectToSpawn.SetActive(true);
        objectToSpawn.transform.position = position;
        objectToSpawn.transform.rotation = rotation;
        
        // Interfaz para objetos pooled
        IPooledObject pooledObj = objectToSpawn.GetComponent();
        pooledObj?.OnObjectSpawn();
        
        return objectToSpawn;
    }
    
    public void ReturnToPool(string tag, GameObject objectToReturn)
    {
        if (!poolDictionary.ContainsKey(tag))
        {
            Debug.LogWarning($"Pool with tag {tag} doesn't exist.");
            return;
        }
        
        objectToReturn.SetActive(false);
        poolDictionary[tag].Enqueue(objectToReturn);
    }
}

// Interfaz para objetos que pueden ser pooled
public interface IPooledObject
{
    void OnObjectSpawn();
}

// Ejemplo de uso en un proyectil
public class Bullet : MonoBehaviour, IPooledObject
{
    [Header("Bullet Settings")]
    public float speed = 10f;
    public float lifetime = 3f;
    
    private Rigidbody2D rb;
    private float timer;
    
    void Awake()
    {
        rb = GetComponent();
    }
    
    public void OnObjectSpawn()
    {
        timer = 0f;
        rb.velocity = transform.right * speed;
    }
    
    void Update()
    {
        timer += Time.deltaTime;
        
        if (timer >= lifetime)
        {
            ReturnToPool();
        }
    }
    
    void OnTriggerEnter2D(Collider2D other)
    {
        if (other.CompareTag("Enemy"))
        {
            // Lógica de daño
            ReturnToPool();
        }
    }
    
    void ReturnToPool()
    {
        FindObjectOfType()?.ReturnToPool("Bullet", gameObject);
    }
}

Tips de Optimización Específicos para Unity 2D

Sprite Atlas y Texture Packing

// Configuración de Sprite Atlas para reducir draw calls:
// 1. Crear Sprite Atlas en Project Window
// 2. Agregar sprites relacionados al atlas
// 3. Configurar Max Texture Size apropiado (1024x1024 o 2048x2048)
// 4. Enable "Include in Build"

// Verificar draw calls en Game Window:
// Stats > Batches (objetivo: < 50 para móviles)

Culling y LOD para 2D

using UnityEngine;

public class Sprite2DCulling : MonoBehaviour
{
    [Header("Culling Settings")]
    public float cullingDistance = 50f;
    public LayerMask cullingLayers;
    
    private SpriteRenderer spriteRenderer;
    private Transform playerTransform;
    private Camera mainCamera;
    
    void Start()
    {
        spriteRenderer = GetComponent();
        mainCamera = Camera.main;
        
        GameObject player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
            playerTransform = player.transform;
    }
    
    void Update()
    {
        if (playerTransform == null || spriteRenderer == null) return;
        
        float distanceToPlayer = Vector2.Distance(transform.position, playerTransform.position);
        
        // Culling basado en distancia
        bool shouldRender = distanceToPlayer <= cullingDistance;
        
        // Culling basado en frustum de cámara
        if (shouldRender && mainCamera != null)
        {
            Bounds bounds = spriteRenderer.bounds;
            shouldRender = GeometryUtility.TestPlanesAABB(
                GeometryUtility.CalculateFrustumPlanes(mainCamera), bounds);
        }
        
        spriteRenderer.enabled = shouldRender;
        
        // Deshabilitar otros componentes si no es visible
        Collider2D col = GetComponent();
        if (col != null && !col.isTrigger)
            col.enabled = shouldRender;
    }
}

Publicación Multiplataforma

Configuración para Móviles

Qué hace: Optimiza tu juego 2D para dispositivos móviles con controles táctiles, gestión de batería y performance adaptativa.

using UnityEngine;

public class MobileInputManager : MonoBehaviour
{
    [Header("Touch Controls")]
    public RectTransform virtualJoystick;
    public RectTransform jumpButton;
    
    [Header("Input Settings")]
    public float joystickRange = 100f;
    public float deadZone = 0.1f;
    
    private Vector2 joystickInput;
    private bool jumpPressed;
    private int joystickFingerId = -1;
    
    void Update()
    {
        HandleTouchInput();
    }
    
    void HandleTouchInput()
    {
        joystickInput = Vector2.zero;
        jumpPressed = false;
        
        for (int i = 0; i < Input.touchCount; i++)
        {
            Touch touch = Input.GetTouch(i);
            
            if (IsOverUI(touch.position, virtualJoystick))
            {
                HandleJoystickInput(touch);
            }
            else if (IsOverUI(touch.position, jumpButton))
            {
                HandleJumpInput(touch);
            }
        }
        
        // Aplicar dead zone
        if (joystickInput.magnitude < deadZone)
            joystickInput = Vector2.zero;
    }
    
    void HandleJoystickInput(Touch touch)
    {
        if (touch.phase == TouchPhase.Began)
        {
            joystickFingerId = touch.fingerId;
        }
        else if (touch.fingerId == joystickFingerId)
        {
            Vector2 localPoint;
            RectTransformUtility.ScreenPointToLocalPointInRectangle(
                virtualJoystick, touch.position, null, out localPoint);
            
            localPoint = Vector2.ClampMagnitude(localPoint, joystickRange);
            joystickInput = localPoint / joystickRange;
            
            if (touch.phase == TouchPhase.Ended || touch.phase == TouchPhase.Canceled)
            {
                joystickFingerId = -1;
                joystickInput = Vector2.zero;
            }
        }
    }
    
    void HandleJumpInput(Touch touch)
    {
        if (touch.phase == TouchPhase.Began)
        {
            jumpPressed = true;
        }
    }
    
    bool IsOverUI(Vector2 screenPosition, RectTransform rectTransform)
    {
        return RectTransformUtility.RectangleContainsScreenPoint(
            rectTransform, screenPosition, null);
    }
    
    public Vector2 GetMovementInput()
    {
        return joystickInput;
    }
    
    public bool GetJumpInput()
    {
        return jumpPressed;
    }
}

Configuración para Web (WebGL)

// Configuración recomendada para WebGL:
// Player Settings > Publishing Settings:
// - Compression Format: Gzip
// - Exception Support: None (para mejor performance)
// - Code Optimization: Master
// - Strip Engine Code: Enabled

// Player Settings > XR Settings:
// - Deshabilitar todas las opciones de VR/AR

// Calidad específica para web:
// Edit > Project Settings > Quality:
// - Texture Quality: Half Res
// - Anisotropic Textures: Disabled
// - Soft Particles: Disabled

¡Eso es todo!

¡Felicidades! Has completado la guía completa de Unity 2D en español. Ahora tienes todas las herramientas necesarias para crear juegos 2D profesionales desde cero hasta la publicación.

Recuerda estos puntos clave:

  • Organiza tu proyecto: Una buena estructura de carpetas ahorra tiempo
  • Optimiza desde el inicio: Object pooling y sprite atlases son fundamentales
  • Piensa en multiplataforma: Diseña UI responsiva desde el principio
  • Usa Physics2D correctamente: Configurar layers y collision matrix apropiadamente
  • Aprovecha el Asset Store: No reinventes la rueda, hay excelentes herramientas disponibles
  • Testea en dispositivos reales: Especialmente importante para móviles

Unity 2D te ofrece herramientas increíblemente poderosas para dar vida a tus ideas. Con esta base sólida y práctica constante, estarás creando juegos 2D increíbles en poco tiempo. ¡Nos vemos en el próximo tutorial! 🎮✨

← Volver a Artículos