Videojuego de cartas hecho con IA local: cómo lo construí con dos tarjetas gráficas modestas

Queridos compañeros,

Tengo muchas cosas pendientes de enseñaros sobre flujos de trabajo con IA local para hardware humilde, pero me apetecía hacer un descanso y usar lo que hemos ido desarrollando durante los artículos anteriores solo para divertirme jugando.

Y con lo de jugando no me refiero solo a jugar con mis flujos de IA local, sino a jugar literalmente.

Para ello me aventuré a crear un videojuego.

Porque enseñaros las herramientas, ponerlas a prueba y mostraros lo que se puede conseguir con hardware antiguo y sin pagar por un solo token, para que podáis ver hasta dónde se puede llegar, es mi cometido.

Y este no deja de ser otro ejemplo más. Pero además de entreteneros leyendo o reproduciendo los experimentos del laboratorio, en esta ocasión podréis disfrutar probando un entretenido juego de cartas.

Un videojuego de cartas completo hecho con IA local: lo que salió

Se llama La Guerra del Umbral y es un juego de cartas para dos jugadores con campaña, partidas online y modo libre. No es una maqueta ni una demo técnica: se puede jugar de principio a fin.

• 212 cartas repartidas en cuatro facciones, cada una con su ilustración, su frase de ambientación y su efecto.
• 340 imágenes generadas con Qwen-Image en una RTX 2080 Super para conseguir esas 212 ilustraciones definitivas, porque muchas hubo que repetirlas varias veces.
• 39 pistas de música compuestas con ACE-Step en una RTX 2060 y 32 efectos de sonido generados por código.
• Cuatro campañas de ocho encuentros cada una, partidas online con emparejamiento por nivel, amigos, salas privadas y un modo libre.
• Unas 10.000 líneas de Python de juego, otras 3.500 de pruebas y 260 pruebas automáticas.
• Interfaz, cartas, campaña y guía completas en español y en inglés.

Todo, en un PC con una RTX 2080 Super de 8 GB, una RTX 2060 de 6 GB y 32 GB de memoria.

En este artículo cuento cómo lo construí, paso a paso: el equipo de agentes que lo hizo, cómo se les organizó para que no se salieran del plan, cómo se pintaron las ilustraciones, cómo se compuso la música, qué fue mal y cómo se arregló. Si te interesan los flujos de IA local en hardware modesto, esta es la parte más útil.

Cómo se juega a La Guerra del Umbral

Si has jugado a juegos de cartas de rondas, el sistema te sonará. Si no, es más sencillo de lo que parece.

No hay vida ni maná. Cada carta aporta puntos de poder a una de tres filas (cuerpo a cuerpo, distancia o asedio) y gana la ronda quien suma más. Gana la partida quien se lleva dos de tres rondas. Cada jugador empieza con dos rubíes y pierde uno cada vez que pierde una ronda.

La gracia está en los efectos. Hay cartas que se potencian al juntarse, otras que duplican una fila, otras que destruyen las más fuertes del campo, climas que lo reducen todo a un punto y espías que juegas en el campo del rival a cambio de robar cartas. Cada efecto tiene su insignia redonda, para que lo reconozcas de un vistazo.

Hay cuatro facciones, cada una con su estilo y su pasiva: los Reinos de Ceniza roban una carta al ganar una ronda, el Círculo Arcano conserva una unidad en el campo, la Corte Umbría gana los empates y los Clanes Salvajes empiezan siempre la partida (si el rival no lo es).

El equipo de agentes de IA local: quién hizo cada cosa

Lo que de verdad quería probar no era solo el juego. Era si se puede coordinar un pequeño estudio de agentes de IA local para hacerlo, cada uno con su especialidad, sin que ninguno se pise con el otro.

El diseño es mío. Todo el trabajo de desarrollo lo hicieron los agentes de Agente Jiménez, mi panel de agentes locales. Si no sabes qué es exactamente un agente de IA ni qué hay detrás de él, lo expliqué con todo detalle en ese mismo artículo.

Agente	Modelo local	Qué hizo	Gráfica
Adolfo y Adolfo-Assistant	Cyber Tiel y Gemma 4	Planificadores: dividen el juego en tareas pequeñas y comprueban cada resultado	Las dos (el modelo se reparte entre ambas)
Adolfo-Dev	Cyber Tiel, con OpenCode	Programación del juego y de sus pruebas	Las dos
Adolfo-Picasso	Qwen-Image 2.1 en ComfyUI	Las ilustraciones de las cartas y los fondos	RTX 2080 Super
Adolfo-BPM	ACE-Step	La música	RTX 2060
Adolfo	Gemma 4	La traducción completa al inglés	Las dos

Cyber Tiel es un modelo de programación de 35.000 millones de parámetros del tipo «mezcla de expertos», con solo 3.000 millones activos por token. Uso la versión Cyber-Tiel-Coder-35B-A3B APEX-I NanoPlus, que ocupa unos 13 GB. Gemma 4 es en realidad la versión gemma-4-26b-a4b QAT, otra mezcla de expertos (26.000 millones de parámetros, 4.000 millones activos) de unos 15,6 GB. Ninguno cabe entero en una tarjeta de 8 GB, pero con las dos gráficas repartiéndose el modelo, y los expertos sobrantes en la memoria del equipo, rinden bien. Adolfo-Dev programa con OpenCode, un agente de programación para la terminal, apoyado en Cyber Tiel. Los modelos los sirvo con LM Studio; si quieres montarlo tú, tienes la guía de instalación de LM Studio y cómo usarlo como servidor desde Python.

Modelo	Solo la 2080 Super	Con las dos tarjetas
Cyber Tiel (35B, 3B activos), medido con la versión Q4_K_S	13 a 14 tokens por segundo	19,7
Gemma 4 26B (4B activos)	16,6	26,9 a 30

Las cifras de Cyber Tiel las medí con su cuantización Q4_K_S, de unos 22 GB; la versión que uso ahora, más pequeña, no la he medido por separado. No son velocidades de nube. Pero para un agente que trabaja de noche mientras tú duermes, sobran. Y si te preguntas hasta dónde llegan estos modelos programando solos en un equipo como este, lo medí en Programación autónoma con IA local: ¿bastan 8 GB de VRAM para programar con modelos de 30B? y comparé trece modelos en ¿Cuál es el mejor modelo de IA local?.

Cómo trabajan los agentes locales: tareas pequeñas, pruebas primero y archivos protegidos

Aquí está lo que más aprendí. Un modelo local con un contexto de 20.000 o 30.000 palabras no puede «entender» un proyecto entero y, si se lo pides, se sale del plan.

Me pasó. Mi primer intento terminó descartado porque el agente no respetó el documento de diseño: inventó datos genéricos, repitió frases y se saltó reglas que estaban escritas. No era falta de capacidad. Era falta de marco.

La segunda vez le di la vuelta al problema. En lugar de pedirle un juego, le di reglas muy estrictas y tareas muy pequeñas.

El documento de diseño y las tareas

Lo primero fue escribir el diseño completo: las reglas del juego, las cuatro facciones, las 212 cartas con su rareza, su poder, su categoría y una descripción de lo que muestra la imagen. Ese diseño vive en ficheros de texto que el agente no puede tocar.

Con el diseño cerrado, el trabajo se troceó en tareas numeradas, cada una en su propio fichero, con la prueba que debe pasar:

• Los textos narrativos de cada facción: las frases de ambientación de sus 53 cartas.
• El constructor del catálogo de cartas, que une el diseño y los textos en un único fichero de datos.
• La inteligencia artificial de los rivales.
• La base de datos de jugadores: cuentas, colección, mazos y campaña.
• El generador de campañas, reproducible: una prueba lo vuelve a generar y comprueba que sale idéntico.

Las reglas del agente

Cada conversación con el agente empieza leyendo un fichero de reglas muy corto. Las más importantes:

• Una sola tarea por conversación.
• Nada de ficheros de más de 150 líneas por escritura: si no cabe, se divide en módulos.
• Si el mismo error aparece tres veces seguidas, parar y contarlo, no improvisar.
• Prohibido tocar las pruebas, el diseño y los scripts de comprobación, y prohibido «bajar el listón» de una prueba para que pase.
• Prohibido generar datos de juego con azar o con plantillas: los textos tenían que ser de verdad, sin repeticiones ni erratas.

Protegido por huella

Las reglas por sí solas no bastan: un modelo local con prisa «arregla» la prueba en lugar del código. Por eso las pruebas de aceptación, el diseño y los scripts de comprobación están protegidos por huella. Un script guarda el hash de cada fichero protegido y los pone en solo lectura. Si el agente los modifica, la comprobación lo detecta y la tarea falla.

Después de cada entrega, otro script ejecuta las pruebas y devuelve un resultado corto y claro. Es importante que sea corto: cada palabra que ocupa en el contexto del agente es una palabra que ya no puede usar para pensar.

El orquestador y el vigilante

Para que trabajara sin mí, escribí un orquestador. Lanza las tareas una tras otra, cada una en una sesión nueva, aprueba los permisos razonables, rechaza las órdenes peligrosas, reintenta con el error real si algo falla, cancela las sesiones que llevan 30 minutos sin actividad y para si el agente toca un fichero protegido. Al terminar deja un informe.

Un segundo proceso, el vigilante, comprueba que todo siga vivo y, al final, ejecuta las pruebas completas y deja un veredicto. Las tareas más largas, la IA rival y la base de datos, le llevaron entre 25 y 30 minutos cada una. Yo solo leía el informe cuando terminaba: todo correcto y 186 pruebas en verde.

Este método tiene mucho en común con lo que cuento sobre agentes en el artículo de Agente Jiménez: un modelo local no necesita más inteligencia, necesita un entorno que le impida equivocarse de formas conocidas.

Las ilustraciones con Qwen-Image y ComfyUI: 340 imágenes para 212 cartas

Cada carta necesitaba una ilustración propia, y las 212 debían parecer del mismo juego. Parece sencillo hasta que lo intentas.

La realidad es que se generaron 340 imágenes para quedarse con 212. Una de cada tres hubo que descartarla y repetirla, algunas más de una vez, porque el modelo no entendía lo que se le pedía o porque, sencillamente, salía mal.

Y no se hizo en una sola noche. Hicieron falta varias noches de generación y muchos ratos sueltos durante el día para corregir diseños mal planteados, repetir cartas y escribir y ajustar todo el código.

Una receta por código, no un prompt por carta

Para conseguir coherencia no escribí 212 descripciones a mano. Cada imagen se construye por código a partir de una receta con un estilo común, la paleta de su facción, su categoría (personaje, criatura, máquina, hechizo, reliquia) y una descripción corta del sujeto. Cada facción tiene su atmósfera: los Reinos de Ceniza, un cielo rojo de atardecer entre humo y brasas; el Círculo Arcano, un cielo nocturno; la Corte Umbría, niebla violeta y luna; los Clanes Salvajes, un bosque viejo, húmedo y oscuro.

El modelo es Qwen-Image 2.1, de 7.000 millones de parámetros y cuantizado a int8, que corro con ComfyUI. Lo instalé con Pinokio, igual que expliqué en la guía para instalar Flux con Pinokio. Desde Agente Jiménez, el agente Adolfo-Picasso arranca y para ComfyUI, le manda las recetas y guarda cada resultado en una galería.

Antes de lanzar las 212, pinté solo cuatro cartas representativas para validar el estilo. Con cada imagen fijé una semilla por carta, de modo que cualquier ilustración se puede reproducir exactamente.

Lo que cuesta pintar en una tarjeta de 8 GB

En la RTX 2080 Super, cada imagen de 768×1152 píxeles tarda unos dos minutos. Las 340 son casi doce horas de tarjeta. Había que cuidar tres cosas:

• Antes de generar se descarga de memoria el modelo de lenguaje de LM Studio, para dejar libre la gráfica.
• Si queda menos de 8 GB de memoria RAM libre, el agente se niega a arrancar ComfyUI. Aprendí por las malas que, con la memoria justa, el equipo entero se cuelga.
• Cada diez imágenes, un descanso de cinco minutos para que la gráfica, que además mueve mi escritorio, respire.

Lo que el modelo no sabe dibujar

Lo que más trabajo dio no fue generar. Fue acertar con lo que el modelo sí sabe dibujar.

• Las ballestas, las catapultas y los potros de tortura salían torcidos una y otra vez, con dos arcos o con piezas que no encajaban. Cambié esos objetos por arcos, arietes, trabuquetes y guillotinas, que sí entiende.
• La honda no la dibujaba bien de ninguna manera. Pasó a ser una jabalina.
• Una vasija con brea ardiendo acababa pegada a la cara del soldado; una antorcha en la mano levantada, en cambio, la dibuja sin problema.
• Mis primeros lobos eran lobos normales con dientes raros. Tuve que redefinir a los Clanes Salvajes como metahumanos con rasgos de animales del bosque, y desde entonces una comprobación automática avisa si una descripción no lo cumple.
• A una de las heroínas salvajes, con rasgos de ave, el modelo le ponía el cuerpo de una hiena con cabeza humana; hizo falta describir el pico, la cresta y los ojos de ave por separado.
• Los Reinos de Ceniza se llenaban de estandartes y engranajes por culpa de la paleta. Lo prohibí en la receta.
• Si el sujeto llevaba una segunda arma, el modelo la dibujaba dos veces. Ahora la receta solo menciona las armas que de verdad lleva la carta.
• La Corte Umbría debe llevar siempre una máscara y nada de verde, porque la palabra «verde» se colaba en el fondo.

Así que antes de generar nada, un script revisa cada descripción contra las reglas de su facción. Generar una imagen mal cuesta dos minutos de tarjeta; revisarla antes cuesta milisegundos.

La revisión humana, carta a carta

Las imágenes no las daba por buenas el modelo. Las revisé yo, una a una, en una página web que hice para eso, con casilla de «correcta», casilla de «regenerar» y una nota de lo que falla.

Esa nota se convierte en una descripción mejorada y se regenera la carta. Con el tiempo afiné el proceso: en lugar de regenerar muchas a la vez, una sola candidata por carta, que yo veo en una pestaña aparte y apruebo o rechazo con una nota. Y lo que se descarta se borra también de la galería, para no acumular imágenes que ya no sirven.

El resultado, facción por facción:

También pinté con el mismo flujo los fondos de las pantallas: el salón del menú, la mesa de estudio de la colección, la mesa de guerra del tablero y, el último, el fondo del menú principal, para el que generé cuatro escenas distintas y elegí la de las cuatro fortalezas.

La música con ACE-Step en la RTX 2060 y los efectos de sonido por código

La RTX 2060 de 6 GB no tiene sitio para Qwen-Image, pero sobra para ACE-Step, un modelo que compone música a partir de una descripción.

Así que mientras la 2080 pintaba cartas, Adolfo-BPM componía en la 2060: 39 pistas de 150 segundos cada una, a razón de cuatro o cinco minutos por pista. Cada una sale de una descripción distinta, como «jiga animada de taberna» o «minueto cortesano alegre», y quedan registradas en un manifiesto para poder regenerar cualquiera sin perder el estilo.

Cada contexto del juego tiene su propia música: el menú, la biblioteca, la campaña, el mapa de cada facción, los duelos, los jefes, y los finales de victoria, derrota y empate. El gestor de audio baraja cada lista y no repite una pista hasta agotarlas todas, y decide la música según el capítulo en el que estás.

Las pistas no las daba por buenas el modelo: hice una herramienta para escucharlas una a una, quedarme con las que valen y descartar las que no.

Los efectos de sonido, 32 en total, no los genera ninguna IA: los sintetiza un script de código. Un clic, un cuerno o un golpe de espada no necesitan un modelo de miles de millones de parámetros, y el resultado es idéntico cada vez. Por defecto, el volumen de la música y el de los efectos están bajos a propósito, porque a la primera partida un juego que grita asusta más que engancha.

El motor del juego, el servidor y el cliente

Debajo de todo esto hay un juego de verdad, con una arquitectura pensada para que se pueda probar y para que nadie haga trampas.

• Motor: determinista, con una semilla. La misma partida con la misma semilla da siempre el mismo resultado, lo que permite repetir cualquier partida y comprobarla.
• Servidor: FastAPI con WebSocket. El servidor es el que manda: el cliente solo dice «quiero jugar esta carta» y el motor decide si es legal. Nunca es el cliente quien declara un ganador.
• Base de datos: SQLite, con cuentas (contraseñas con scrypt), colección, mazos, campaña y amigos.
• Cliente: Pygame, con estilo medieval y mágico, animaciones y música.
• Partidas online: emparejamiento por nivel con un margen que se amplía con la espera, lista de amigos, invitaciones, salas privadas y 120 segundos para volver si se te corta la conexión (si no vuelves, pierdes la partida y tu rival gana).

Lo probé con 260 pruebas automáticas. Las del servidor las validé además con «mutaciones»: se estropea el código a propósito de 17 maneras y se comprueba que las pruebas lo detectan. Detectaron 16, y la que se les escapó resultó ser equivalente.

La IA rival: demasiado buena, y cómo la nivelé midiendo partidas

La IA que juega contra ti decide simulando cada jugada posible sobre una copia de la partida y quedándose con la que más puntos da. Hay tres niveles de dificultad: aprendiz, estratega y maestro.

Funciona. Demasiado bien.

Cuando lo probé, el rival del primer encuentro de la campaña ganaba casi siempre y sumaba casi el doble de puntos que yo. Para un tutorial, un desastre.

Así que dejé de opinar y medí. Puse a un jugador automático de nivel intermedio con el mazo básico a jugar decenas de partidas contra cada rival, y probé dos remedios:

• Que el mazo del rival use solo cartas que el jugador ya podría tener en ese punto de la campaña, y que sume como mucho una fracción de la fuerza del suyo.
• Que la IA falle a propósito, eligiendo una jugada al azar con una probabilidad que baja a medida que avanza la campaña.

Primer encuentro de la campaña	Victorias del jugador antes de nivelar	Victorias del jugador después
Reinos de Ceniza	27 %	85 %
Círculo Arcano	43 %	65 %
Corte Umbría	40 %	70 %
Clanes Salvajes	47 %	82 %

La dificultad sube a lo largo de la campaña hasta que los jefes vuelven a ser un reto. Y al superar las cuatro campañas se abre un modo libre, con rivales de facción aleatoria y una puntuación tipo Elo que sube y baja con tus resultados.

Iconos, animaciones y guía: detalles que hacen que el juego se entienda

Un juego de cartas con efectos es difícil de leer si todas las cartas se parecen. Casi la mitad del pulido final fue hacer que se entendiera de un vistazo.

• Insignias redondas para cada efecto (vínculo, moral, cuerno, espía, médico, reunión, calcinar, señuelo y los tres climas) y otra para la fila donde juega cada unidad.
• Ficha flotante con la descripción completa al pasar el ratón por cualquier carta.
• Un marcador claro, con el rival en rojo y tú en azul, los puntos en grande, los rubíes y el cuadro que dice de quién es el turno.
• Animaciones para todo lo que pasa: las cartas vuelan a su fila, el rival «piensa» un momento antes de jugar, una moneda decide quién empieza y cada ronda termina con un aviso.
• Un sobre de recompensa que llega volando cuando ganas un encuentro, y que se abre para enseñarte las cartas nuevas.

• Una guía integrada con tutorial de la primera partida, las reglas y cada insignia explicada.

La traducción al inglés con Gemma 4

Esta es una tarea ideal para un modelo local, y se la di a Gemma 4: los nombres y las frases de ambientación de las 212 cartas, 280 frases de interfaz más 80 patrones con números y nombres, los textos de la campaña y la guía del juego.

Para no dejar nada en español por descuido hice una herramienta que recorre todas las pantallas del juego en inglés y lista cualquier frase que siga sin traducir. Mientras no devuelve cero, no está terminado. Desde Ajustes se cambia de idioma al instante.

Despliegue, servidor online y control de versiones

El servidor online corre en un VPS con un servicio de sistema y un proxy inverso con cifrado, con copias de seguridad de la base de datos. Lo desplegué con una prueba de principio a fin desde fuera: registrar dos jugadores, emparejarlos y jugar una partida.

El juego también comprueba su versión. Cada vez que arranca, y mientras el servidor esté activo, pregunta cuál es la versión más reciente; si la tuya es anterior, te avisa con un enlace a esta página. El servidor, además, puede rechazar a un cliente demasiado antiguo cuando cambie algo que lo haga incompatible.

Lo que aprendí construyendo un videojuego con IA local

• Los modelos locales no necesitan un proyecto: necesitan una tarea. Pequeña, con una prueba y con un marco que les impida salirse.
• Protege lo que no debe tocarse. Las pruebas y el diseño fuera del alcance del agente evitan que «arregle» una prueba en lugar del código.
• Comprueba antes de generar. Una regla automática que rechaza una descripción mala ahorra horas de tarjeta gráfica.
• Cuenta con repetir. Para quedarte con 212 imágenes buenas, cuenta con generar 340. No es un fallo: es el coste de tener criterio.
• Mide, no opines. El rival me parecía «un poco difícil»; la simulación dijo que ganaba casi todas las partidas.
• Reparte las tarjetas. Que una pinte mientras la otra compone multiplica lo que sale de cada noche de trabajo.
• Y revisa con tus ojos. La IA hace el trabajo. El criterio sigue siendo tuyo.

Si quieres seguir esta línea, tienes más experimentos en mi sección de IA local y sistemas de inteligencia artificial y los tutoriales de IA local y modelos en tu propio equipo.

Descarga, versiones y partidas online

Versión del experimento (1.0.0): con sus bugs

Estos son los ficheros tal como salieron del experimento y se quedan aquí como su resultado, con los errores que aparecieron al probarlos. Descarga La Guerra del Umbral 1.0.0 si quieres ver el experimento tal cual (un solo fichero, sin instalar nada). En Linux, descomprime el archivo y haz doble clic en LaGuerraDelUmbral; en Windows, descomprime el zip y abre LaGuerraDelUmbral.exe. La primera vez tendrás que aceptar la licencia. Como el programa no está firmado digitalmente, Windows puede avisar con «Windows protegió su PC»: pulsa «Más información» y «Ejecutar de todas formas».

El fallo más importante de la 1.0.0: no se conecta al servidor online oficial, así que no funcionan ni las partidas online ni el modo amigo. Además, como no llega al servidor, tampoco puede avisarte de que existe una versión nueva: si ya la tienes, descarga la actual a mano desde aquí abajo. El marco amarillo de abajo marca lo que se conserva como resultado del experimento.

Versión actual (1.0.1): solo por placer

Estos botones ofrecen la release más actual, pero solo por placer: ya no es el resultado del experimento y no cuenta como tal. Corrige errores y mejora la experiencia de los usuarios (por ejemplo, se conecta bien al servidor oficial para las partidas online y con amigos), así que es la descarga adecuada para quien solo quiere disfrutar del juego. Se instala y se abre igual que la anterior. Si lo único que buscas es jugar, esta es la mejor opción: la del marco verde.

Esta página es la casa del juego: aquí estará siempre publicada la versión más actual, que ahora es la 1.0.1.

El juego se encarga de recordártelo (a partir de la 1.0.1). Cada vez que lo abres, y mientras mi servidor esté activo, comprueba si tienes la última versión. Si no la tienes, te sale un aviso con un enlace directo a esta página para descargarla, y si una versión antigua deja de ser compatible, te lo dice y te pide actualizar. El enlace del aviso va a la página en tu idioma: la de castellano o la de inglés.

El servidor online es oficial, pero temporal

Las partidas online (emparejamiento por nivel, amigos y salas privadas) se juegan a través de mi servidor. Mientras esté abierto, ese es el servidor oficial.

Pero no será eterno: lo mantendré activo solo de forma temporal.

Cuando lo cierre, publicaré aquí mismo el código y las instrucciones para que puedas crear tu propio servidor local en tu ordenador y jugar partidas PvP con tus amigos.

La campaña y el modo libre contra la IA se juegan en tu propio equipo y no dependen de mi servidor.

Si te gusta lo que ves, si quieres que esto siga creciendo o simplemente que haya más laboratorios como este, puedes invitarme a un café.

Sigue explorando la IA local

• IA local frente a la nube: privacidad, potencia y límites reales.
• TRELLIS 2 en 8 GB: generar modelos 3D localmente, otra prueba de hasta dónde llega una tarjeta de 2019.
• Clonar tu voz en local con 8 GB.

Preguntas frecuentes sobre hacer un videojuego con IA local

¿Se puede hacer un videojuego completo con IA local?

Sí. Este tiene 212 cartas ilustradas, música, campaña, partidas online y traducción al inglés. Lo que hace falta no es una máquina enorme sino método: tareas pequeñas, pruebas, archivos protegidos y revisión humana.

¿Qué hardware hace falta?

Yo usé una RTX 2080 Super de 8 GB, una RTX 2060 de 6 GB y 32 GB de memoria. Con una sola tarjeta también se puede, pero tarda más porque no puedes pintar y componer a la vez.

¿Cuántas imágenes hay que generar para 212 cartas?

Muchas más de las que parece: yo generé 340 para quedarme con 212, porque una de cada tres hubo que repetirla. A unos dos minutos por imagen en una RTX 2080 Super, son casi doce horas de tarjeta.

¿Qué modelo de imágenes usaste?

Qwen-Image 2.1 (7.000 millones de parámetros, cuantizado a int8) en ComfyUI. Lo más importante no fue el modelo sino saber qué sabe dibujar y qué no: las ballestas, las hondas y las catapultas salían mal y las cambié por objetos que sí entiende.

¿Cómo se compone música con IA local?

Con ACE-Step, un modelo local que compone a partir de una descripción. Cada pista de 150 segundos tardó cuatro o cinco minutos en una RTX 2060, y los efectos de sonido los generé por código.

¿Por qué los modelos locales se pierden en proyectos largos?

Porque su contexto es corto, de unas 20.000 a 30.000 palabras. La solución es darles tareas pequeñas, un marco de reglas muy claro y pruebas que no puedan tocar.

¿Se puede jugar online?

Sí, mientras mi servidor oficial esté activo: partidas con emparejamiento por nivel, lista de amigos y salas privadas. Es un servidor temporal; cuando lo cierre publicaré en esta misma página el código para montar tu propio servidor local y jugar PvP con tus amigos.

¿Cómo sé si tengo la última versión?

El juego lo comprueba solo al abrirse, siempre que el servidor oficial esté activo. Si hay una versión más nueva, te avisa con un enlace a esta página, que siempre ofrece la más actual.