Crea un Videojuego con IA en 2 Semanas, Sin Código

Creamos el prefab base de la carta y revisamos como va a funcionar dentro del proyecto. Esta leccion deja preparada la pieza principal que se va a reutilizar durante todo el juego.

Armamos el tablero base donde se van a instanciar y organizar las cartas. Tambien dejamos preparada la escena para empezar a construir la logica del juego.

Creamos un script para instanciar varias cartas en una grilla 3x3 dentro del board. Ademas, pedimos explicaciones y comentarios en el codigo para entender paso a paso que hace cada parte.

Repasamos la logica del sistema inicial para entender como se conecta el prefab, el board y el spawner. La idea es que puedas leer el codigo generado y saber como modificarlo sin depender a ciegas de la IA.

Introducimos que son los MCPs y por que sirven para conectar herramientas externas con asistentes de IA. Esta base permite que Claude o Codex puedan interactuar mejor con Unity y el proyecto.

Probamos la conexion del MCP de Unity dentro de Claude y resolvemos los primeros problemas de instalacion. Luego usamos el MCP para crear objetos, scripts y configuraciones directamente en la escena.

Verificamos la conexion del MCP desde Codex y revisamos como se puede usar en el flujo de trabajo. Esta leccion muestra como alternar entre herramientas de IA manteniendo acceso al proyecto.

Integramos GitHub Desktop al flujo para guardar cambios y trabajar con versiones del proyecto. Tambien hacemos una modificacion simple en el spawner para validar el ciclo de cambio y control de versiones.

Importamos el modelo 3D de la carta y lo dejamos listo para usar dentro del prefab. Esta leccion prepara la base visual del juego antes de avanzar con la logica.

Ajustamos la camara para que el tablero y las cartas se vean correctamente en la escena. El objetivo es tener una vista clara y usable para probar el gameplay.

Configuramos las dimensiones de las cartas para que el sistema pueda calcular posiciones y espacios con precision. Esto permite que el level builder y el tablero trabajen con medidas coherentes.

Construimos la primera version del level builder para pintar celdas, guardar niveles y cargar configuraciones. Tambien definimos que el tablero se adapte al contenido creado por el jugador.

Corregimos la aplicacion de colores para que las cartas usen el material correcto segun lo pintado en el level builder. Esta leccion conecta la informacion del editor de niveles con la representacion visual del juego.

Mejoramos el level builder para crear grupos verticales de cartas con espaciado controlado. Agregamos acciones como borrar, arrastrar para pintar, mover la grilla y mostrar coordenadas.

Ajustamos detalles del level builder como posicion de cartas, orden de dibujo, textos, controles y organizacion de UI. Tambien empezamos a mover parte de la interfaz a objetos reales en la escena usando MCP.

Agregamos la posibilidad de crear chunks horizontales ademas de verticales. La leccion trabaja con direcciones, rotaciones y flechas visuales para que cada grupo de cartas comunique hacia donde va.

Implementamos la creacion, guardado, ordenamiento y carga de multiples niveles. Tambien mejoramos el escalado del board para que se ajuste al contenido real de cada nivel.

Limpiamos scripts sin uso, reorganizamos carpetas y separamos responsabilidades entre managers y objetos de UI. Esta leccion mejora la estructura del proyecto para que sea mas facil mantenerlo.

Creamos un sistema para que la camara mantenga visible el tablero segun el tamano de cada nivel. Tambien ajustamos valores de margen y padding para evitar encuadres incorrectos.

Agregamos flechas a los chunks para mostrar la direccion de movimiento. Tambien corregimos rotaciones y posicionamiento para que la flecha aparezca en la carta central correcta.

Implementamos el movimiento de chunks al hacer clic, incluyendo colisiones, rebotes y salida hacia el borde del tablero. La leccion tambien optimiza el uso de colliders para manejar muchas cartas.

Revisamos la organizacion de scripts relacionados con cartas, chunks y UI. El objetivo es que cada clase viva en la carpeta correcta y tenga una responsabilidad clara.

Creamos el sistema de orders para que las cartas que salen del tablero vuelen hacia slots de colores especificos. Tambien agregamos animaciones, capacidad maxima y reemplazo de ordenes completadas.

Analizamos como funcionan varias orders simultaneas y que reglas deben cumplirse para llenarlas correctamente. Esta leccion sirve para entender el comportamiento esperado antes de seguir programando.

Validamos que los niveles generen cantidades compatibles con la capacidad de las orders. Tambien hacemos que cada order acepte solo cartas de su color y muestre informacion mas clara.

Corregimos problemas al borrar, seleccionar direcciones y mantener chunks como cadenas validas. Tambien mejoramos casos raros donde se generaban cartas de mas o flechas incorrectas.

Ajustamos el encuadre para que la camara tenga en cuenta tanto el tablero como las orders. Tambien separamos responsabilidades para que el board, las orders y la camara se reposicionen de forma ordenada.

Creamos la pantalla de nivel completado y una UI para mostrar el nivel actual. Ademas, agregamos una reserva para manejar cartas sobrantes sin romper el flujo de orders.

Pulimos las interfaces existentes para que se vean mejor y funcionen de forma mas clara dentro del juego. Esta leccion se enfoca en ajustes visuales y de uso antes de seguir agregando sistemas.

Hacemos una pasada de refactor para ordenar managers, scripts de level builder, UI y jerarquia de escena. La meta es dejar el proyecto listo para escalar con nuevos sistemas.

Introducimos la logica de la reserva y como debe integrarse con el tablero, las orders y el encuadre vertical. Tambien empezamos a adaptar la escena para una experiencia mobile portrait.

Ajustamos el framing para que el tablero y las orders queden correctamente visibles. Esta leccion refuerza la importancia de calcular limites reales antes de mover la camara.

Adaptamos las interfaces al formato vertical del juego. El foco esta en reorganizar elementos para que funcionen mejor en mobile.

Repasamos visualmente como debe comportarse la reserva dentro del flujo de gameplay. Esto ayuda a definir mejor que se espera antes de implementar la cinta.

Le pedimos a Claude construir una reserva tipo cinta con puntos editables, portales y visuales en escena. La leccion muestra como describir un sistema complejo para que la IA lo implemente en Unity.

Iteramos sobre la cinta para corregir puntos, diagonales, portales y reconstruccion visual. Tambien buscamos que el sistema sea editable y claro fuera de play mode.

Corregimos casos al cambiar niveles, limpiar presets anteriores y mantener la cinta alineada con su forma. Esta parte mejora la robustez del sistema de reservas.

Arreglamos puntos que quedaban fuera del path de la cinta. La leccion se enfoca en que los datos y los visuales coincidan exactamente.

Corregimos rotaciones y escala de cartas dentro de la reserva para que se vean naturales al circular. Tambien ocultamos flechas y reutilizamos el espaciado del tablero.

Dividimos scripts largos de la cinta y reorganizamos jerarquia, managers y tweens. Esta leccion convierte un sistema que crecio rapido en una arquitectura mas mantenible.

Mejoramos las animaciones de salida del tablero, vuelo hacia orders o reserva y feedback de colision. El objetivo es que las cartas se muevan en cadena y con transiciones mas claras.

Agregamos controles para crear, borrar y administrar niveles desde el level builder. Tambien corregimos problemas cuando muchas cartas vuelan al mismo tiempo.

Ajustamos el punto de entrada de las cartas a la reserva para evitar clipping. Tambien agregamos previsualizacion y offsets configurables para afinar el movimiento.

Implementamos un loop de niveles para que el juego continue aunque se complete el ultimo nivel disponible. Ademas, reforzamos la logica de reserva y orders para manejar cartas en vuelo sin errores.

Corregimos el comportamiento de slots vacios y el orden en que las cartas salen de la reserva. Tambien diferenciamos gizmos y mejoramos la lectura visual de los puntos de tween.

Empezamos a crear niveles con IA usando archivos JSON y reglas persistentes en markdown. Esta leccion muestra como documentar aprendizajes para que la IA construya niveles con mas consistencia.

Mejoramos las reglas para que los niveles generados por IA sean jugables y tengan direcciones variadas. Tambien corregimos formas existentes para que sean mas atractivas y posibles de resolver.

Exploramos como convertir imagenes en niveles jugables usando una paleta limitada y una resolucion razonable. Tambien ajustamos la UI para trabajar mejor con referencias visuales.

Refinamos la traduccion de imagenes a pixeles y chunks para que respete mejor la referencia original. La leccion corrige interpretaciones erroneas y problemas de escala.

Corregimos celdas sin chunk, reglas mal guardadas y problemas de comunicacion con los archivos guia. Tambien mejoramos las instrucciones para que la IA recuerde actualizar la documentacion del proyecto.

Generamos nuevos niveles a partir de imagenes y corregimos errores de colores, multiples y jugabilidad. La leccion muestra como iterar con IA hasta que los niveles sean reconocibles y posibles.

Arreglamos problemas visuales y de uso en la interfaz del level builder. El objetivo es que crear y editar niveles sea mas comodo antes de avanzar a niveles grandes.

Cambiamos la logica de posicionamiento para soportar niveles mas grandes que la grilla original. Reposicionamos board, orders y cinta para mantener margenes correctos.

Pulimos presets de cinta, anclajes y frames de camara para que funcionen con tableros grandes. Esta leccion resuelve casos donde el path o el encuadre quedaban fuera de lugar.

Usamos las nuevas capacidades para crear niveles grandes a partir de imagenes. Tambien corregimos rellenos, siluetas, multiplos y direcciones para preservar la referencia sin romper la jugabilidad.

Cerramos la iteracion sobre niveles grandes creados con IA. La leccion consolida el flujo para generar, revisar y ajustar contenido de mayor escala.

Construimos la interfaz visual del menu principal y revisamos como encaja con el resto del juego. Esta leccion prepara la pantalla de entrada antes de conectarla con la logica.

Conectamos el boton Play para cargar la escena de gameplay y mostrar el nivel actual. Tambien empezamos a manejar el progreso entre menu y juego.

Modificamos el sistema para que un chunk pueda dividirse si solo una parte puede ir a orders o reserva. Esto evita perder cartas y permite completar niveles en situaciones mas complejas.

Ajustamos la UI de gameplay para que no tape elementos importantes como la cinta. La leccion se enfoca en compatibilizar informacion en pantalla con el espacio jugable.

Creamos o ajustamos la pantalla visual de nivel completado. Esta interfaz prepara el cierre de cada nivel antes de sumar logica y recompensas.

Conectamos la logica de nivel completado con botones, avance de nivel y controles dedicados. Tambien creamos un manager para centralizar esta parte del flujo.

Armamos la pantalla de game over y conectamos sus botones principales. Primero dejamos la interfaz lista antes de definir exactamente cuando debe aparecer.

Agregamos animaciones y juice a la pantalla de game over usando fades, escalas y delays configurables. La leccion muestra como pedirle a la IA una secuencia de UI mas expresiva.

Aplicamos animaciones similares a la pantalla de level complete. Ajustamos entradas, delays y movimiento de botones para que la UI se sienta mas pulida.

Analizamos en que situaciones el jugador puede quedarse sin movimientos o sin espacio. Esta leccion define las reglas antes de implementarlas en codigo.

Preparamos la pantalla de Need Space como aviso antes del game over. La idea es darle al jugador una opcion cuando la reserva esta al limite.

Implementamos una evaluacion periodica del estado del tablero, la reserva y las orders. La logica decide cuando mostrar Need Space o Game Over sin interrumpir acciones en curso.

Conectamos los botones de Need Space, limites por sesion y transiciones hacia game over. Tambien corregimos casos de progreso incorrecto al volver al menu.

Agregamos una UI anclada al portal de entrada para mostrar la capacidad de la reserva. El sistema permite ajustar offsets y previsualizar la posicion fuera de play mode.

Sumamos animaciones al contador de capacidad de la cinta cuando entran o salen cartas. Tambien agregamos feedback visual al aumentar capacidad y evitamos que los cambios simultaneos rompan la UI.

Creamos un sistema de monedas con recompensas por nivel, wallet y animaciones de monedas volando. Tambien conectamos el gasto de monedas con acciones como conseguir mas espacio.

Ajustamos la pantalla de level complete para que las monedas vuelen al wallet correcto y muestren la recompensa del nivel. Tambien pulimos el comportamiento del boton Claim.

Preparamos la interfaz de power-ups dentro del gameplay. Esta leccion deja listos los botones y valores visuales para conectar cada poder con su logica.

Implementamos el power-up de order extra usando el sistema de monedas existente. Tambien respetamos limites de ordenes simultaneas y bloqueos cuando no corresponde comprarlo.

Conectamos el power-up de aumentar reserva con la misma logica del boton Get Space. La leccion centraliza limites por sesion para que ambos caminos respeten la misma regla.

Creamos el power-up de pista para destacar un chunk jugable con flash verde y una mano animada. El sistema intenta elegir el mejor movimiento posible y cancelar el efecto cuando el jugador interactua.