🎮 UnityDocs
Modo aprender

Ruta de aprendizaje

El mismo contenido que en Referencia, pero ordenado como un curso: de lo más básico a lo más avanzado, paso a paso. Ideal si empiezas de cero.

  1. Qué es Unity y cómo piensa el motor Una visión de conjunto antes de tocar nada: qué es un motor de videojuegos, qué te da Unity, cómo se estructura un proyecto (escenas, GameObjects, componentes, assets) y qué tipo de juegos puedes hacer. 📄 Principiante · 📖 6 min
  2. Instalar Unity: Hub, versiones y editor de código El primer paso para empezar: instalar Unity Hub, elegir la versión correcta (Unity 6 LTS), añadir los módulos que necesitas y configurar un editor de código. Sin liarte con las versiones. 📄 Principiante · 📖 6 min
  3. Variables y tipos en C# El primer ladrillo de la programación en Unity: qué es una variable, los tipos básicos de C# (int, float, bool, string), la f de los decimales y cómo se usan dentro de un script. 📄 Principiante · 📖 6 min
  4. Control de flujo en C#: condicionales y bucles Cómo tomar decisiones (if, else, switch) y repetir acciones (for, foreach, while) en C#. La lógica con la que tu juego reacciona y procesa cosas, con los operadores de comparación y lógicos. 📄 Principiante · 📖 7 min
  5. Métodos y funciones en C# Cómo agrupar código reutilizable en métodos: parámetros, valores de retorno, void, sobrecargas, parámetros opcionales y out/ref. La pieza que evita repetir código y mantiene tus scripts ordenados. 📄 Principiante · 📖 7 min
  6. Clases y objetos en C# El pilar de la programación orientada a objetos: qué es una clase, qué es un objeto, campos, métodos, constructores y propiedades. Y cómo se relaciona con los MonoBehaviour de Unity. 📄 Principiante · 📖 8 min
  7. Herencia e interfaces en C# Cómo reutilizar y organizar código con herencia (una clase que parte de otra) e interfaces (un contrato de comportamiento). Con polimorfismo, virtual/override y por qué las interfaces son tan potentes en juegos. 📄 Intermedio · 📖 9 min
  8. Colecciones en C#: array, List y Dictionary Cómo guardar muchos datos: arrays (tamaño fijo), List (dinámica) y Dictionary (pares clave-valor). Cuál usar en cada caso, cómo recorrerlos y sus trampas de rendimiento en Unity. 📄 Intermedio · 📖 8 min
  9. El editor de Unity: tour de ventanas Las ventanas que usarás siempre (Hierarchy, Scene, Game, Inspector, Project, Console), el modo Play y los atajos esenciales. Orientarte en el editor antes de programar. 📄 Principiante · 📖 7 min
  10. El Package Manager (UPM) Cómo gestionar paquetes en Unity con el Package Manager: qué son los paquetes oficiales, cómo añadirlos (incluidos los preview/experimental y por Git URL), el archivo manifest.json y por qué conviene fijar versiones en un proyecto de equipo. 📄 Principiante · 📖 7 min
  11. GameObjects y Componentes La idea central de Unity: todo en tu juego es un GameObject (un contenedor) al que das forma y comportamiento añadiéndole Componentes. Entender esto lo cambia todo. 📄 Principiante · 📖 6 min
  12. Transform: mover, rotar y escalar El componente que tiene todo GameObject: posición, rotación y escala, además de la jerarquía padre-hijo. Cómo moverlo por código, la diferencia entre espacio local y global, y por qué la rotación usa Quaternion. 📄 Principiante · 📖 8 min
  13. Rotaciones 3D y Quaternions Por qué rotar en 3D es engañoso: el gimbal lock, la diferencia entre ángulos de Euler y Quaternions, y cómo hacer las tareas reales (mirar a un objetivo, girar suave, rotar sobre un eje) con LookRotation, Slerp y RotateTowards sin volverte loco. 📄 Avanzado · 📖 9 min
  14. Sprites, Sprite Renderer y Sorting Layers La base del 2D en Unity: cómo importar sprites correctamente (Pixels Per Unit, filtro, compresión), dibujarlos con el Sprite Renderer y controlar qué se dibuja delante de qué con Sorting Layers y Order in Layer. 📄 Principiante · 📖 8 min
  15. Mallas y geometría 3D Qué hay dentro de un modelo 3D: vértices, triángulos, normales y UVs. Cómo Unity lo dibuja con MeshFilter + MeshRenderer, qué es el recuento de polígonos y por qué importa, y una introducción a generar mallas por código. 📄 Intermedio · 📖 8 min
  16. Prefabs: plantillas reutilizables Qué es un prefab, por qué son la base de todo proyecto ordenado, cómo crearlos y usarlos, y qué son las variantes y los overrides. Sin prefabs no hay producción. 📄 Principiante · 📖 6 min
  17. Tags y Layers Dos sistemas que se confunden a menudo: las Tags (etiquetas para identificar objetos) y las Layers (capas para filtrar física y renderizado). Qué son, en qué se diferencian y cómo usar cada una bien. 📄 Intermedio · 📖 6 min
  18. Escenas y SceneManager Qué es una escena, cómo cambiar de nivel con SceneManager, la diferencia entre carga síncrona y asíncrona, las escenas aditivas y por qué debes añadirlas a los Build Profiles. 📄 Principiante · 📖 7 min
  19. Crear escenarios 3D: blockout y ProBuilder Cómo construir niveles 3D dentro de Unity: el blockout (greybox) con primitivas para probar el diseño antes que el arte, ProBuilder para modelar geometría sin salir del editor, el grid snapping y el trabajo con piezas modulares. 📄 Intermedio · 📖 8 min
  20. El ciclo de vida de MonoBehaviour Qué métodos llama Unity automáticamente (Awake, Start, Update, FixedUpdate, LateUpdate…), en qué orden y para qué sirve cada uno. El concepto que lo cambia todo cuando empiezas a programar en Unity. 📄 Intermedio · 📖 9 min
  21. Time, deltaTime y timeScale Cómo mide el tiempo Unity y por qué casi todo movimiento se multiplica por Time.deltaTime. Las diferencias entre deltaTime, fixedDeltaTime y unscaledDeltaTime, y cómo pausar o ralentizar el juego con timeScale. 📄 Principiante · 📖 7 min
  22. Update vs FixedUpdate vs LateUpdate Los tres bucles de actualización de Unity, cuándo usar cada uno y por qué mezclarlos provoca movimientos temblorosos. Con una regla simple para no equivocarte nunca. ⚖️ Intermedio · 📖 7 min
  23. Corrutinas en Unity Cómo hacer que algo ocurra a lo largo del tiempo (esperar, repetir, encadenar acciones) sin bloquear el juego, usando corrutinas y yield. 📄 Avanzado · 📖 7 min
  24. [SerializeField] vs public Las dos formas de exponer una variable en el Inspector y por qué [SerializeField] private es casi siempre la correcta. Encapsulación desde el minuto uno, explicada con ejemplos. ⚖️ Principiante · 📖 5 min
  25. Instantiate y Destroy: crear y eliminar objetos Cómo crear GameObjects en tiempo de ejecución a partir de prefabs y cómo eliminarlos. Incluye las sobrecargas útiles, los errores típicos y por qué el pooling suele ser mejor que crear y destruir sin parar. 📄 Intermedio · 📖 6 min
  26. GetComponent a fondo Cómo acceder a otros componentes desde un script: GetComponent, TryGetComponent, las variantes InChildren e InParent, y por qué nunca debes llamarlo en Update. 📄 Principiante · 📖 6 min
  27. Input: leer teclado, ratón y mando Los dos sistemas de entrada de Unity: el clásico Input Manager (rápido para empezar) y el nuevo Input System (recomendado para proyectos serios). Cuándo usar cada uno y cómo se escribe. 📄 Intermedio · 📖 8 min
  28. Matemáticas para juegos: vectores, Lerp y Mathf Las matemáticas que de verdad usarás: operar con Vector3 (distancia, normalizar, producto escalar), interpolar con Lerp/MoveTowards para movimientos suaves, y las utilidades de Mathf. Sin fórmulas intimidantes. 📄 Intermedio · 📖 9 min
  29. Rigidbody: física de movimiento El componente que somete un objeto al motor de física. Cómo moverlo con fuerzas y velocidades, los ForceMode, isKinematic vs dinámico, interpolación y los cambios de nombre en Unity 6. 📄 Intermedio · 📖 8 min
  30. Movimiento 3D: CharacterController vs Rigidbody Las dos formas de mover un personaje 3D y cuándo usar cada una: el CharacterController (control preciso, tú aplicas la gravedad, pensado para personajes) frente al Rigidbody (física real). Pendientes, escalones, gravedad y salto bien hechos. 📄 Intermedio · 📖 8 min
  31. Colliders y triggers La diferencia entre chocar (colisión) y atravesar detectando el paso (trigger), qué componentes hacen falta, los métodos OnCollision/OnTrigger y la tabla de qué combinaciones funcionan. 📄 Intermedio · 📖 8 min
  32. Raycasting: lanzar rayos Cómo lanzar un rayo invisible para saber qué golpea: disparos hitscan, detección de suelo, interacción con objetos, clics en el mundo. Con RaycastHit, LayerMask y las variantes útiles. 📄 Intermedio · 📖 8 min
  33. El Animator: máquina de estados de animación Cómo funciona el sistema de animación de Unity: estados, transiciones, parámetros y blend trees. Cómo controlarlo desde código con SetFloat, SetBool y SetTrigger sin liarte. 📄 Intermedio · 📖 8 min
  34. Canvas y anclas: UI que se adapta Cómo funciona la interfaz en Unity: el Canvas, sus modos de render, el Canvas Scaler para múltiples resoluciones y las anclas (anchors), la clave para que la UI no se descoloque en móvil. 📄 Principiante · 📖 7 min
  35. Botones y eventos de UI Cómo hacer que un botón haga algo: conectarlo desde el Inspector con onClick o por código, cargar escenas, salir del juego y las buenas prácticas para menús. 📄 Principiante · 📖 6 min
  36. TextMeshPro: texto de calidad El estándar de texto en Unity: por qué TextMeshPro sustituye al Text clásico, cómo funcionan sus fuentes SDF (nítidas a cualquier tamaño), el texto enriquecido (rich text), y cómo cambiarlo por código. 📄 Principiante · 📖 7 min
  37. Audio en Unity: AudioSource y Mixer Cómo reproducir música y efectos: AudioSource, AudioClip, PlayOneShot, el audio espacial 2D/3D y el Audio Mixer para controlar volúmenes y añadir efectos. 📄 Principiante · 📖 7 min
  38. Cámaras y Cinemachine Cómo funciona la cámara en Unity y por qué deberías usar Cinemachine para que siga al jugador de forma profesional sin escribir código. Con la versión manual y el porqué de LateUpdate. 📄 Intermedio · 📖 7 min
  39. Introducción a URP: materiales e iluminación Qué son los render pipelines (Built-in, URP, HDRP), por qué Unity 6 usa URP por defecto, y las bases de materiales, luces e iluminación para que tu escena 3D se vea bien. 📄 Intermedio · 📖 8 min
  40. Materiales y texturas Los fundamentos antes de los shaders: qué es un material, la diferencia con una textura, los mapas PBR (albedo, normal, metallic, roughness) y cómo el shader Lit de URP los combina para dar aspecto realista a una superficie. 📄 Principiante · 📖 8 min
  41. Eventos y delegados en Unity Cómo hacer que unas partes del juego avisen a otras sin acoplarse, usando delegados, Action, C# events y UnityEvent. La base de un código desacoplado y mantenible. 📄 Avanzado · 📖 9 min
  42. ScriptableObject: datos como assets Qué es un ScriptableObject, qué problema resuelve frente a MonoBehaviour, cómo usarlo para configurar armas o enemigos sin duplicar datos, y por qué es la base de arquitecturas dirigidas por datos. 📄 Avanzado · 📖 9 min
  43. Patrón Singleton en Unity El patrón para tener un gestor único y accesible desde cualquier parte (GameManager, AudioManager). Cómo implementarlo bien en Unity, sus trampas y cuándo NO usarlo. 🧩 Intermedio · 📖 7 min
  44. Máquina de estados (State Machine) Cómo organizar comportamientos que cambian (IA que patrulla, persigue y ataca; el estado del jugador) sin llenar Update de ifs. El patrón State explicado y aplicado a Unity. 🧩 Avanzado · 📖 8 min
  45. IA con NavMesh: enemigos que persiguen Cómo hacer que un enemigo navegue por el escenario esquivando obstáculos con el sistema NavMesh y NavMeshAgent. Perseguir, patrullar y el cambio de flujo en Unity 6 (paquete AI Navigation). 📄 Avanzado · 📖 8 min
  46. PlayerPrefs: guardar ajustes y récords El sistema más simple para guardar datos pequeños entre sesiones (volumen, récord, opciones). Cómo se usa, dónde se guarda y por qué NO sirve para guardar partidas. 📄 Principiante · 📖 5 min
  47. Organiza tu proyecto: carpetas, nombres y estructura Cómo estructurar un proyecto de Unity para que no se vuelva un caos cuando crece: convención de carpetas, nombres consistentes, separación de responsabilidades y assembly definitions. 📄 Intermedio · 📖 7 min
  48. Git para Unity: control de versiones sin romper nada Cómo usar Git en un proyecto de Unity: qué ignorar, por qué necesitas Git LFS para los assets grandes, cómo evitar conflictos en escenas y prefabs, y un flujo de ramas sencillo. 📄 Intermedio · 📖 8 min
  49. Object Pooling: reciclar en vez de crear Por qué crear y destruir objetos sin parar provoca tirones, y cómo un pool reutiliza objetos para evitarlo. Con la clase ObjectPool integrada en Unity 6 y un ejemplo de balas. 📄 Avanzado · 📖 8 min
  50. El Profiler: mide, no adivines La herramienta para saber en qué se va el rendimiento de tu juego. Cómo leer el Profiler, el concepto de frame budget, y por qué optimizar sin medir es perder el tiempo. 📄 Avanzado · 📖 8 min
  51. Gestión de memoria y el recolector (GC) Por qué el recolector de basura provoca tirones y cómo escribir código que apenas genera basura: value types, cachear, evitar concatenar strings y las asignaciones ocultas en el bucle de juego. 📄 Avanzado · 📖 9 min
  52. Particle System: efectos visuales Cómo crear efectos con el Particle System de Unity (humo, fuego, chispas, magia): los módulos clave, cómo controlarlo por código, y cuándo dar el salto al VFX Graph para efectos masivos por GPU. 📄 Intermedio · 📖 7 min
  53. Job System y Burst: usar todos los núcleos Cómo mover trabajo pesado a varios hilos de forma segura con el C# Job System y acelerarlo con el compilador Burst. Qué son NativeArray, IJobParallelFor y cuándo merece la pena. 📄 Avanzado · 📖 9 min
  54. Editor scripting: personaliza el Inspector Cómo mejorar tu flujo de trabajo con atributos del Inspector (Header, Tooltip, Range, ContextMenu) y editores personalizados (CustomEditor). Herramientas hechas a medida sin salir de Unity. 📄 Avanzado · 📖 8 min
  55. Introducción a DOTS y ECS Qué es DOTS y su arquitectura ECS (Entity Component System), por qué permite decenas de miles de objetos, en qué se diferencia del Unity clásico (GameObjects) y —lo más importante— cuándo NO deberías usarlo. 📄 Avanzado · 📖 8 min
  56. Conceptos de multiplayer: cómo funciona el juego en red Los fundamentos que valen para cualquier tecnología de red: cliente-servidor, autoridad, sincronización, RPC, predicción y reconciliación, y P2P frente a servidor dedicado. Léelo antes de elegir herramienta. 📄 Avanzado · 📖 10 min
  57. Latencia: interpolación, predicción y reconciliación Por qué el lag hace que el multiplayer se sienta mal y las tres técnicas que lo esconden: interpolación (los demás se ven suaves), predicción del cliente (te mueves al instante) y reconciliación (el servidor corrige). 📄 Avanzado · 📖 9 min
  58. Netcode for GameObjects: la base oficial La solución de red oficial de Unity. Cómo se monta (NetworkManager, NetworkObject), cómo sincronizar estado con NetworkVariable y acciones con RPC, y las novedades de NGO 2.x en Unity 6. 📄 Avanzado · 📖 11 min
  59. Sincronizar estado: NetworkVariable, RPC y NetworkTransform El corazón del multiplayer con Netcode: cuándo usar NetworkVariable (estado continuo) frente a RPC (eventos puntuales), cómo sincronizar el movimiento con NetworkTransform y quién tiene la autoridad. 📄 Avanzado · 📖 9 min
  60. Netcode vs Mirror vs Photon vs Steam: qué elegir Las principales soluciones de red para Unity comparadas: Netcode for GameObjects, Mirror, Photon (Fusion/PUN) y la integración con Steam. Coste, dificultad y para qué brilla cada una. ⚖️ Avanzado · 📖 9 min
  61. Unity Relay y Lobby: jugar online sin servidores Cómo conectar jugadores por internet sin abrir puertos ni montar servidores: Relay retransmite el tráfico y Lobby gestiona las salas y el emparejamiento. La vía moderna para publicar multiplayer con Netcode. 📄 Avanzado · 📖 8 min
  62. Multiplayer con Steam: lobbies y P2P Cómo usar la plataforma de Steam para el multiplayer: lobbies, invitaciones de amigos y su red P2P con relay, combinada con Mirror o Netcode. Qué librería usar y qué necesitas para probar y publicar. 📄 Avanzado · 📖 9 min
  63. Exportar y publicar tu juego Cómo generar la build de tu juego en Unity 6 (Build Profiles), las particularidades de cada plataforma, WebGL, y dónde publicar: Steam, itch.io, móvil. El paso final para que el mundo juegue a tu juego. 📄 Intermedio · 📖 8 min