25 Prompts de IA que Todo Desarrollador de Juegos Debería Guardar

Actúa como un desarrollador senior de Unity. Escribe un script C# llamado `SimplePlayerController.cs` para un controlador de personaje en primera persona.
Debe cumplir estos requisitos:
1.  Usar el componente `UnityEngine.CharacterController` para el movimiento. NO usar un Rigidbody.
2.  Incluir variables públicas de tipo float para `playerSpeed`, `jumpHeight` y `gravityValue`.
3.  En el método `Update()`, leer la entrada de los ejes estándar "Horizontal" y "Vertical".
4.  Calcular la dirección del movimiento basándose en los vectores `forward` y `right` de la cámara.
5.  Manejar el salto con el botón "Jump" (barra espaciadora). Aplicar gravedad en cada frame.
6.  Incluir una implementación sencilla de vista con el ratón que rote el objeto del jugador horizontalmente y el objeto de la cámara verticalmente. Crear un float público para `mouseSensitivity`.
Añadir comentarios para explicar las secciones clave.

Actúa como un programador de juegos de Unity. Crea un conjunto de tres scripts C# para un sistema de inventario básico utilizando ScriptableObjects.
1.  **`ItemData.cs`**: Debe ser un ScriptableObject. Necesita campos para `itemName` (string), `itemIcon` (Sprite) y `itemDescription` (string).
2.  **`InventorySlot.cs`**: Una clase sencilla (no un MonoBehaviour) para contener un `ItemData` y una `amount` (int). Esto se usará dentro de la lista de inventario.
3.  **`InventorySystem.cs`**: Debe ser un MonoBehaviour. Necesita una `public List<InventorySlot> inventory` para contener los ítems. Crea métodos públicos para `AddItem(ItemData item, int amount)` y `RemoveItem(ItemData item, int amount)`. El método `AddItem` debe apilar ítems si ya existen en el inventario.
Asegúrate de que todos los scripts estén en el namespace `MyGame.Inventory`.

Actúa como un desarrollador de Unity C#. Escribe un script llamado `PrefabSpawner.cs` que genere un prefab dado en posiciones aleatorias dentro de un área definida.
Requisitos:
1.  Un `public GameObject prefabToSpawn`.
2.  Un `public int numberOfPrefabs`.
3.  Un `public Vector3 spawnAreaSize` para definir los límites de una caja donde los prefabs pueden aparecer.
4.  Un método `SpawnPrefabs()` que se repita `numberOfPrefabs` veces.
5.  Dentro del bucle, calcula una posición aleatoria `x`, `y` y `z` dentro de `spawnAreaSize` centrada en la posición de la transformación del generador.
6.  Usa `Instantiate()` para crear el prefab en la posición aleatoria.
7.  Llama a `SpawnPrefabs()` en el método `Start()`.

Actúa como un programador senior de Unity. Crea un script C# `HealthSystem.cs` para un jugador o enemigo.
El script debe:
1.  Usar el namespace `System` para eventos.
2.  Definir `public event Action<int, int> OnHealthChanged;` para transmitir actualizaciones de salud. Los parámetros son la salud actual y la salud máxima.
3.  Definir `public event Action OnDied;` para señalar cuando la salud llega a cero.
4.  Tener campos enteros privados para `_currentHealth` y `_maxHealth`. Crear una propiedad pública `CurrentHealth` con un setter privado.
5.  En el método `Awake()`, establecer `_currentHealth` a `_maxHealth`.
6.  Crear un método público `TakeDamage(int damageAmount)`. Este método debe reducir la salud, limitarla a 0 e invocar el evento `OnHealthChanged`. Si la salud es 0, debe invocar el evento `OnDied`.
7.  Crear un método público `Heal(int healAmount)`. Esto debe aumentar la salud, limitarla a `_maxHealth` e invocar `OnHealthChanged`.

Actúa como un programador de Unity C#. Escribe una clase Singleton genérica y reutilizable llamada `Singleton.cs`.
Requisitos:
1.  La clase debe ser genérica: `public class Singleton<T> : MonoBehaviour where T : Component`.
2.  Necesita un `private static T _instance;` para mantener la referencia.
3.  Necesita una propiedad `public static T Instance`. El getter debe ser el punto de acceso público.
4.  En el getter de la propiedad `Instance`, verifica si `_instance` es nulo. Si lo es, busca el objeto de tipo `T` en la escena y asígnalo. Si sigue siendo nulo, crea un nuevo GameObject y añádele el componente `T`.
5.  En el método `Awake()`, maneja la lógica del Singleton. Si `_instance` es nulo, asígnale `this`. Si `_instance` ya existe y no es `this`, destruye el GameObject actual para aplicar el patrón singleton.
6.  Usa `DontDestroyOnLoad(this.gameObject)` para que persista entre escenas.

Actúa como un desarrollador del Motor Godot. Escribe un GDScript para un controlador de jugador 2D.
El script debe adjuntarse a un nodo `KinematicBody2D`.
1.  Define variables exportadas para `speed`, `jump_strength` y `gravity`.
2.  Usa una variable `Vector2` llamada `velocity` para rastrear el movimiento del jugador.
3.  En la función `_physics_process(delta)`:
a. Aplica gravedad a `velocity.y`.
b. Obtén la entrada del jugador para "ui_left" y "ui_right" para establecer la velocidad horizontal.
c. Maneja el salto verificando `is_on_floor()` y la acción "ui_up".
d. Usa `move_and_slide(velocity, Vector2.UP)` para mover al personaje.
Añade comentarios explicando cada parte de la función `_physics_process`.

Actúa como un desarrollador de Godot creando un script global. Escribe un GDScript para un Singleton de carga automática llamado `SceneTransition.gd`. Este script gestionará los cambios de escena con un efecto de fundido.
1.  El script debe tener una función `change_scene(path)` que tome una ruta de escena como argumento.
2.  Requiere un nodo `ColorRect` y un nodo `AnimationPlayer` como hijos para funcionar. Asume que el `AnimationPlayer` tiene dos animaciones: "fade_to_black" y "fade_to_normal".
3.  La función `change_scene` debe:
a. Reproducir la animación "fade_to_black".
b. `yield` hasta que la animación termine.
c. Llamar a `get_tree().change_scene(path)` para cargar la nueva escena.
d. `yield` por un frame para permitir que la nueva escena se cargue.
e. Reproducir la animación "fade_to_normal".
Este script debe configurarse como un Singleton de Carga Automática en la Configuración del Proyecto de Godot.

Actúa como un experto en GDScript de Godot. Proporciona dos ejemplos cortos de GDScript que demuestren señales personalizadas.
**Script 1: `Player.gd`**
1.  Este script es para el jugador.
2.  Define una señal personalizada llamada `health_depleted`.
3.  Crea una función `take_damage()`. Cuando se llama a esta función, debe `emit_signal("health_depleted")`.
4.  Para demostración, añade una línea para llamar a `take_damage()` cuando se presiona la entrada "ui_accept".
**Script 2: `GameUI.gd`**
1.  Este script es para la escena principal de la interfaz de usuario.
2.  En la función `_ready()`, obtén el nodo del jugador (asume que está en `/root/Game/Player`).
3.  Conecta la señal `health_depleted` del jugador a una nueva función en este script llamada `_on_Player_health_depleted`.
4.  La función `_on_Player_health_depleted` debe imprimir el mensaje "¡Salud del jugador agotada! Fin del juego." en la consola.

Actúa como un desarrollador de juegos de Godot. Escribe un GDScript para una IA enemiga sencilla utilizando una máquina de estados.
El script debe adjuntarse a un enemigo `KinematicBody2D`.
1.  Usa un `enum` para definir los estados: `PATROL`, `CHASE`.
2.  Crea una variable `state`, con valor predeterminado `PATROL`.
3.  En `_physics_process(delta)`, usa una declaración `match` para ejecutar código basado en el `state` actual.
4.  **Estado de Patrulla:**
a. Mueve al enemigo a la izquierda o a la derecha.
b. Usa un `RayCast2D` para detectar paredes o salientes. Si se detecta una pared, invierte la dirección.
c. Usa un `Area2D` para detectar al jugador. Si el jugador entra en el área de detección, cambia el `state` a `CHASE`.
5.  **Estado de Persecución:**
a. Obtén la dirección hacia el jugador.
b. Muévete hacia el jugador.
c. Si el jugador abandona el área de detección, cambia el `state` de nuevo a `PATROL`.
Proporciona marcadores de posición para la lógica de detección del jugador.

Actúa como un especialista del Motor Godot. Escribe un GDScript que genere proceduralmente un mapa simple utilizando un nodo `TileMap`.
El script debe adjuntarse a un nodo `TileMap`.
1.  Exporta variables para `map_width`, `map_height`, `noise_scale` y `tile_index_ground`.
2.  En la función `_ready()`, crea un nuevo objeto `OpenSimplexNoise`.
3.  Recorre cada coordenada x e y desde 0 hasta `map_width` y `map_height`.
4.  Dentro del bucle, obtén un valor de ruido del objeto `OpenSimplexNoise` usando `get_noise_2d(x * noise_scale, y * noise_scale)`.
5.  Si el valor de ruido está por encima de un cierto umbral (por ejemplo, 0.5), usa `set_cell(x, y, tile_index_ground)` para colocar un tile de suelo.

Actúa como un experto en construcción de mundos para un videojuego. Estoy creando una nueva facción para mi RPG de mundo abierto, que tiene una ambientación "magitek" (magia fusionada con tecnología industrial temprana).
La facción se llama "Escribas de Engranaje". Genera una historia de fondo detallada para ellos, incluyendo:
1.  **Origen:** ¿Cómo y por qué fueron fundados?
2.  **Ideología:** ¿Cuál es su creencia u objetivo principal?
3.  **Estructura:** ¿Cómo están organizados? (ej., líderes, rangos)
4.  **Relación con la Magia y la Tecnología:** ¿Cómo ven la fusión de magia y tecnología? ¿Son innovadores, tradicionalistas o reguladores?
5.  **Conflictos:** ¿Quiénes son sus principales aliados y enemigos? ¿Qué conflictos internos enfrentan?
Mantén un tono serio y fundamentado. El resultado debe tener alrededor de 400 palabras.

Actúa como un diseñador narrativo. Escribe una escena de diálogo ramificado para un personaje jugador (PJ) y un guardia PNJ sospechoso llamado Marcus. El PJ está intentando pasar una puerta que Marcus está custodiando.
El objetivo es pasar la puerta. Proporciona tres caminos distintos:
1.  **Persuasión:** El PJ intenta convencer a Marcus con una mentira plausible.
2.  **Soborno:** El PJ ofrece oro a Marcus.
3.  **Intimidación:** El PJ insinúa una amenaza.
Para cada camino, escribe la respuesta inicial de Marcus y luego dos posibles resultados (éxito o fracaso) basados en una elección posterior. Formatea el resultado como un árbol o lista anidada para que las ramas sean claras.

Actúa como un diseñador de misiones para un juego de acción y aventura. Necesito una misión secundaria llamada "La Campana Silenciosa".
El escenario es un monasterio remoto en la montaña. La premisa es que la campana gigante del monasterio, que ahuyenta a los espíritus malignos, ha dejado de sonar.
Genera un esquema de misión con la siguiente estructura:
- **Dador de Misión:** Hermano Kael, el monje principal preocupado.
- **El Enganche:** ¿Cuál es el problema inicial que se presenta al jugador?
- **Paso 1: Investigación:** ¿Qué necesita descubrir el jugador primero? (ej., la campana está físicamente intacta pero mágicamente silenciada).
- **Paso 2: La Causa:** ¿Cuál es la fuente del silencio mágico? (ej., un culto rival ha colocado una "piedra amortiguadora" cerca).
- **Paso 3: La Solución:** ¿Qué debe hacer el jugador para arreglarlo? (ej., encontrar y destruir tres runas de poder atadas a la piedra amortiguadora).
- **Paso 4: Clímax:** ¿Qué sucede cuando el jugador intenta destruir la runa final? (ej., una emboscada del líder del culto rival).
- **Resolución y Recompensa:** La campana vuelve a sonar, y el Hermano Kael le da al jugador un objeto mágico único.

Actúa como un escritor narrativo. Estoy construyendo un nivel que es un laboratorio de alquimista abandonado en una ciudad steampunk. El alquimista, Elias, estaba intentando en secreto crear una piedra filosofal, pero algo salió terriblemente mal.
Escribe una serie de tres entradas de diario cortas desde la perspectiva de Elias que el jugador puede encontrar dispersas por el laboratorio. Las entradas deben crear suspense y contar la historia de su fracaso sin decirlo directamente.
- **Entrada 1:** Lleno de esperanza y emoción, al borde de un gran avance.
- **Entrada 2:** La paranoia y la frustración se están apoderando. El proceso es inestable, y menciona extraños efectos secundarios.
- **Entrada 3:** Desesperación y pánico. La entrada final, escrita momentos antes del desastre, describiendo cómo la piedra se vuelve volátil y algo "se desmorona".

Actúa como un diseñador de juegos senior. Estoy diseñando un juego de plataformas de puzles 2D con el tema de "luz y sombra". El personaje del jugador es una pequeña criatura hecha de luz.
Genera cinco mecánicas centrales únicas basadas en este tema. Para cada mecánica, proporciona:
1.  **Nombre:** Un nombre claro y descriptivo (ej., "Fusión de Sombra").
2.  **Descripción:** ¿Cómo funciona la mecánica desde la perspectiva del jugador?
3.  **Ejemplo de Puzle:** Un puzle sencillo que solo podría resolverse usando esta mecánica.

Actúa como un diseñador de juegos escribiendo un Documento de Diseño de Juego (GDD). Necesito la sección que describe el bucle de jugabilidad central para un juego de supervivencia y crafteo ambientado en un planeta alienígena hostil.
El documento debe ser claro, profesional y usar el formato estándar de GDD (encabezados, viñetas).
Cubre las siguientes fases del bucle:
1.  **EXPLORAR:** Los jugadores se aventuran a buscar recursos. ¿Cuáles son los riesgos y los objetivos?
2.  **RECOLECTAR:** Los jugadores recolectan materiales (ej., flora alienígena, restos). ¿Cómo se hace esto?
3.  **REGRESAR:** Los jugadores deben llevar los recursos de vuelta a una base segura. ¿Qué peligros enfrentan en el viaje de regreso?
4.  **FABRICAR/CONSTRUIR:** Los jugadores usan recursos para fabricar herramientas, armas y componentes de base. ¿Cómo es la interfaz de crafteo?
5.  **SOBREVIVIR:** ¿Cómo ayudan los objetos fabricados al jugador a sobrevivir el siguiente ciclo (ej., fauna hostil, peligros ambientales)?

Actúa como un diseñador de niveles y artista ambiental. Escribe una descripción de una página para un nuevo nivel en un juego post-apocalíptico. El nivel se llama "La Biblioteca Sumergida".
La descripción debe evocar un ambiente fuerte y proporcionar una dirección clara para un equipo de arte. Incluye detalles sobre:
- **Ubicación:** Una enorme biblioteca pública pre-guerra que se ha derrumbado parcialmente en un sumidero inundado.
- **Atmósfera:** ¿Cuál es el ambiente? (ej., tranquilo, espeluznante, reverente). ¿Cuáles son las características clave de iluminación y sonido?
- **Áreas Clave:** Describe tres zonas distintas dentro del nivel (ej., La Gran Rotonda, Los Archivos Inundados, El Asentamiento de Chozas en la Azotea).
- **Desplazamiento:** ¿Cómo navega el jugador por el espacio? (ej., puentes improvisados, escalando estanterías derrumbadas, buceando por secciones inundadas).
- **Puntos de Interés:** ¿Qué hitos únicos o elementos narrativos existen? (ej., una habitación protegida con libros impecables, un esqueleto de un superviviente que hizo una última resistencia).

Actúa como un escritor de UX y diseñador de juegos. Escribe el texto del tutorial para una nueva habilidad en un juego de acción de ritmo rápido. La habilidad se llama "Salto de Fase" (Phase Dash), y permite al jugador teletransportarse una corta distancia, pasando a través de enemigos y proyectiles.
El texto debe entregarse a través de ventanas emergentes de UI no intrusivas. Escribe tres mensajes de tutorial cortos, claros y concisos:
1.  **Introducción:** Aparece cuando el jugador desbloquea la habilidad por primera vez. Explica el comando básico (ej., "Pulsa [RB] para Salto de Fase").
2.  **Uso Contextual (Ofensivo):** Aparece cuando el jugador se enfrenta a un enemigo con escudo por primera vez. Sugiere usar el salto para ponerse detrás de ellos (ej., "Atraviesa a los enemigos con escudo para golpear su punto débil.").
3.  **Uso Contextual (Defensivo):** Aparece cuando el jugador es objetivo de un proyectil potente. Sugiere usar el salto para evitarlo (ej., "Calcula tu salto para atravesar ataques entrantes.").

Genera una hoja de sprites de pixel art para un personaje de videojuego.
**Sujeto:** Un pícaro goblin. Es pequeño, delgado y lleva una capucha y capa de cuero oscuro. Empuña dos pequeñas dagas.
**Estilo:** 16 bits, alto contraste, fantasía, estilo de JRPGs clásicos como Chrono Trigger. Paleta de colores saturados.
**Disposición:** Una hoja de sprites de cuadrícula 4x4 sobre un fondo gris neutro.
**Animaciones:**
- Fila 1: Animación de inactividad (4 frames)
- Fila 2: Ciclo de caminar (4 frames)
- Fila 3: Animación de ataque (4 frames, un rápido tajo con dos dagas)
- Fila 4: Reacción de daño/golpe (4 frames)
Asegúrate de que cada frame sea distinto y muestre claramente el movimiento deseado.

Genera un conjunto de mapas de textura PBR sin fisuras para un panel de suelo de nave espacial de ciencia ficción.
**Descripción:** Un panel metálico cuadrado, gris oscuro con patrones hexagonales y sutiles líneas emisivas naranjas brillantes. Debe parecer desgastado y usado, con pequeños arañazos y rozaduras, pero no muy dañado.
**Estilo:** Ciencia ficción industrial, cruda, realista.
**Mapas a Generar:**
- Albedo (Color Base)
- Mapa Normal (formato DirectX)
- Mapa de Rugosidad
- Mapa Metálico
- Mapa Emisivo
El resultado debe tener una resolución de 4K.

Genera arte conceptual de alta calidad para una criatura de fantasía llamada "Ciervo de Bosque Brillante" (Glimmerwood Stag).
**Descripción:** Un ciervo grande y majestuoso. Su cuerpo está hecho de madera antigua cubierta de musgo. Sus astas son cristalinas, pulsando con una suave luz interna azul. Sus ojos brillan con la misma luz azul. Es un guardián de un bosque antiguo.
**Composición:** El ciervo está de pie en un claro por la noche, iluminado por la luz de la luna que se filtra a través del dosel. Luciérnagas flotan a su alrededor.
**Estilo:** Muy detallado, fotorrealista, iluminación cinematográfica, ilustración de fantasía, estilo de Greg Rutkowski y Loish.
**Ambiente:** Sereno, mágico, poderoso, misterioso.

Genera un modelo 3D low-poly de un cofre del tesoro estilizado, listo para un motor de juego.
**Descripción:** Un clásico cofre del tesoro de madera con herrajes de hierro y un candado sencillo. El estilo debe ser robusto y estilizado, adecuado para un juego móvil de fantasía.
**Especificaciones Técnicas:**
- **Conteo de Polígonos:** Menos de 800 triángulos.
- **Formato:** Archivo GLB.
- **Texturas:** Un único mapa de color de 1024x1024 de estilo pintado a mano. No se necesitan materiales PBR. La textura debe estar integrada en el modelo.
- **Detalles:** La tapa debe ser un objeto separado, con su punto de pivote correctamente colocado en la bisagra para facilitar la apertura en el motor.

Actúa como un líder de QA para un estudio de juegos. Necesito un plan de pruebas para una nueva característica: un modo de fotografía en nuestro juego de aventuras de mundo abierto.
Genera un plan de pruebas en formato de tabla markdown. Las columnas deben ser: `ID del Caso de Prueba`, `Componente`, `Descripción de la Prueba`, `Resultado Esperado` y `Prioridad (Baja/Media/Alta)`.
Cubre los siguientes componentes:
- **UI/UX:** Entrar y salir del modo de fotografía, navegar por la interfaz de usuario.
- **Controles de Cámara:** Movimiento libre de la cámara (paneo, inclinación, dolly, truck), campo de visión, rotación.
- **Filtros y Efectos:** Aplicar filtros de color, profundidad de campo, viñeta.
- **Controles de Personaje:** Ocultar el personaje del jugador, cambiar poses.
- **Casos Extremos:** Usar el modo de fotografía durante el combate, en cinemáticas, mientras se nada, sobre una montura.

Actúa como un analista de QA. Tengo tres informes de errores enviados por jugadores. Para cada informe, clasifica su prioridad y sugiere una posible causa.
**Informe 1:** "A veces, cuando vendo ítems al vendedor muy rápido, mi juego se cierra al escritorio. Sucedió dos veces anoche."
**Informe 2:** "La textura del 'Escudo de Hierro' se ve estirada y rara por un lado. Es solo algo visual, pero se ve mal."
**Informe 3:** "Me quedé atascado en una pared en el nivel de las Cavernas de Cristal detrás de una roca y tuve que recargar mi partida guardada para salir."
Proporciona tu análisis en este formato para cada informe:
- **Resumen:**
- **Prioridad:** (Bloqueador / Crítico / Mayor / Menor / Trivial)
- **Componente Probable:** (ej., UI, Activo de Arte, Colisión/Física, IA)
- **Siguiente Paso Sugerido:** (ej., "Intentar reproducir con acciones rápidas de inventario", "Verificar el mapa UV del modelo del Escudo de Hierro.")

Actúa como un desarrollador de Unity con experiencia en desarrollo basado en pruebas. Tengo un script `HealthSystem.cs` con un método `TakeDamage(int damage)`.
Escribe un script de prueba unitaria C# simple para este método usando `NUnit.Framework` y `UnityEngine.TestTools`. La prueba debe verificar que la salud del personaje se reduce correctamente después de recibir daño.
El script de prueba debe:
1.  Llamarse `HealthSystemTests.cs`.
2.  Incluir un método de prueba `TakeDamage_ReducesHealth_Correctly()`.
3.  Dentro de la prueba, crea un nuevo GameObject y añádele el componente `HealthSystem`.
4.  Establece la salud inicial en 100.
5.  Llama al método `TakeDamage(10)`.
6.  Usa `Assert.AreEqual(90, healthSystem.CurrentHealth)` para verificar el resultado.