Un editor de escenarios puede hacer que los encuentros de un shooter de arena rápido den más juego al repetirlos, pero no debe convertirse en un segundo motor de combate. Deja que el editor describa el encuentro y que el juego siga gestionando el movimiento, las armas, el comportamiento de los enemigos, el daño y el desarrollo de la partida.

Esta guía describe un flujo de creación de escenarios para un proyecto existente. Foundry Arena es un ejemplo ficticio y no se afirma que se haya creado un editor, generado una compilación ni realizado una prueba de juego. Antes de pedirle a la IA que cambie el código, identifica los sistemas que ya funcionan y deben seguir siendo estables, y revisa cómo carga el proyecto las arenas que trae de serie.
Delimita el alcance del editor antes de añadir controles
Parte de lo que el juego ya admite. Si las arenas ya tienen límites fijos, puntos de aparición del jugador, tipos de enemigos y recogidas de munición, una primera versión del editor puede ofrecer esas opciones. No hace falta un lenguaje de scripting, herramientas para crear geometría arbitraria ni un mercado completo de mods. Esas funciones multiplican los requisitos de validación y seguridad.
Define en lenguaje sencillo los datos mínimos de un escenario. Especifica qué arena se carga, dónde empieza el jugador, qué grupos de enemigos aparecen, cuándo se activa cada grupo, cuánta munición o armadura hay disponible y cómo termina el encuentro. Conserva el ajuste de las armas y la IA de los enemigos en sus sistemas actuales. El editor selecciona las opciones admitidas y deja que los sistemas existentes apliquen las reglas correspondientes.
Pide a la IA que describa el flujo actual antes de editar el código. Pídele que identifique cómo se inicia una arena desde la campaña o el menú, qué función coloca a los enemigos y qué componente gestiona la condición de victoria. Solicita un plan breve de cambios y la lista exacta de archivos que prevé modificar. Si propone sustituir el bucle de combate actual para simplificar el editor, detén el trabajo y acota el alcance.
Representa el escenario mediante datos
Los identificadores estables importan más que los nombres que aparecen en un desplegable. Un campo puede hacer referencia al ID de una arena, de un enemigo, de un punto de aparición o de un objeto que se pueda recoger. Más adelante, los diseñadores podrán cambiar el nombre de «Entrada de la fundición» sin invalidar un escenario que use el ID estable foundry_gate_a.
Un registro de ejemplo podría incluir estos campos:
{
"scenario_id": "foundry_arena_01",
"arena_id": "foundry_main",
"player_start_id": "west_platform",
"waves": [
{"delay": 0, "spawns": [{"enemy_id": "raider", "count": 3}]},
{"delay": 20, "spawns": [{"enemy_id": "brute", "count": 1}]}
],
"ammo_budget": 120,
"win_condition_id": "clear_all_waves"
}
Es un ejemplo didáctico cuyo esquema no se ha probado. Respeta las convenciones del proyecto sobre unidades y tiempos. Si los tiempos de espera se miden en segundos, utiliza esa unidad de forma coherente. Si las oleadas se activan mediante eventos, evita introducir un segundo reloj. Incluye una versión del esquema si los escenarios personalizados deben seguir funcionando tras las actualizaciones del proyecto y decide cómo se notificará la eliminación de ID de enemigos o arenas.
Elige el formato de datos según cómo se creen y distribuyan los escenarios. La documentación de la versión estable de Godot describe los Resources personalizados, que se pueden editar en el Inspector y serializar como texto o en formato binario. Su tutorial de guardado usa JSON para estados de ejecución sencillos y explica aspectos como la conversión de tipos y la codificación personalizada. Unity 6.1 describe ScriptableObject como un contenedor de datos del editor independiente de las instancias de clase. Cada opción tiene su ámbito de uso. Comprueba cómo empaqueta y carga los datos el proyecto actual.

Impide que se inicien escenarios no válidos
Valida los datos antes de iniciar la escena de combate. Comprueba que la arena seleccionada existe, que el punto de inicio del jugador pertenece a esa arena, que se reconocen todos los ID de enemigos, que el número de enemigos por oleada y los tiempos de espera son válidos, y que la condición para completar el encuentro se puede cumplir. Si el juego asigna costes a los recursos, aplica un límite claro y rechaza los valores que no puedan cubrirse con los objetos disponibles.
Indica en cada error qué campo hay que corregir y qué hacer. «ID de enemigo desconocido en la oleada 2» resulta más útil que «Escenario no válido». Si un punto de aparición queda fuera de la zona jugable, indica al autor de qué punto se trata. Evita aplicar valores predeterminados sin avisar. Si un escenario parece haberse guardado correctamente pero carga un enemigo distinto, puede hacer perder tiempo a quien lo creó y ocultar un error en los datos.
Aplica restricciones acordes con el juego. Una arena muy estrecha puede cumplir las reglas y aun así resultar injusta. El editor puede avisar si el espacio queda por debajo de un umbral definido en el proyecto, sin pretender evaluar el equilibrio de forma automática. La cantidad de enemigos, la línea de visión, la munición y la dificultad se influyen entre sí. Las comprobaciones estáticas pueden detectar datos mal formados. Las pruebas de juego siguen siendo necesarias para saber si el encuentro es divertido y se puede completar.
Mantén la validación separada del combate. Un validador sencillo puede devolver una lista de errores y avisos. La pantalla de vista previa puede mostrar esos mensajes y desactivar el botón «Iniciar» hasta que se corrijan los errores que impiden empezar. Así, el cargador de arenas existente recibe datos ya validados.
Usa el flujo real de combate para la vista previa
La vista previa solo resulta útil si carga el escenario por la misma vía que una partida normal. Haz que el editor guarde o mantenga en memoria los datos del escenario y los pase al punto de entrada que ya usa la arena. Una vista previa simulada que coloca a los enemigos de forma distinta a la escena de combate real deja la integración incompleta.
Para una primera versión, elige una arena incluida en el juego y un conjunto reducido de ID de enemigos conocidos. Añade un encuentro personalizado con dos oleadas, un presupuesto de recursos y la condición de victoria existente. Conserva el escenario actual de la campaña como referencia. Compara el comportamiento del movimiento, las armas, los enemigos y el reinicio antes y después de incorporar el editor.

Usa la IA para crear una implementación que puedas revisar
Da al asistente unas instrucciones breves y precisas. Debe conservar los scripts de movimiento y combate, ofrecer solo las opciones de arena, aparición, enemigos, ritmo y recursos que ya existan, validar antes del inicio y mantener la vía de carga original de los escenarios incluidos en el juego. Pídele que indique qué ha dado por hecho sobre el formato de datos, qué archivos ha cambiado, qué impacto tendrá la migración y cómo revertir los cambios.
Revisa las diferencias de código en bloques pequeños. Comprueba que los ID de escenario sean estables, que las referencias que falten generen un mensaje útil y que el editor no sobrescriba el contenido incluido en el juego. Si los escenarios creados por los usuarios se guardan por separado, deja clara esa separación. Conserva una copia del proyecto original y al menos un archivo de escenario existente para poder comparar cómo se cargan.
El código generado por la IA puede parecer correcto y, aun así, duplicar la lógica de combate o introducir una dependencia oculta de recursos que solo están disponibles en el editor. Compila el proyecto y revisa los registros de ejecución con la configuración de destino. Que la vista previa funcione en el editor no demuestra que el contenido exportado se cargue ni que el encuentro esté equilibrado.
Prueba la carga del contenido además de la pantalla del editor
Usa una tabla de pruebas breve y anota la versión del proyecto, el ID del escenario, los pasos, el resultado esperado y el resultado observado. Estas comprobaciones son propuestas y no implican que la arena ficticia las haya superado.
| Caso | Comprobación | Comportamiento esperado |
|---|---|---|
| Escenario incluido en el juego | Inicia la arena original desde el menú habitual | La campaña y el combate siguen funcionando como antes |
| Datos personalizados válidos | Carga un escenario con dos oleadas conocidas y un presupuesto dentro de los límites permitidos | La posición del jugador, las apariciones, el ritmo y la condición de victoria se ajustan a los datos |
| Referencia desconocida | Usa una copia desechable en la que falte un ID de enemigo | La validación identifica el campo que falta e impide iniciar el escenario |
| Caso límite | Coloca un punto de aparición cerca del límite de la arena o fuera de él | El editor muestra un aviso o rechaza el punto según las reglas del proyecto |
| Reinicios repetidos | Reinicia el mismo escenario varias veces | Las apariciones y las cantidades de recursos se restablecen de forma coherente |
Prueba después una compilación exportada si está prevista para el lanzamiento. Comprueba que los escenarios de usuario estén incluidos o se carguen desde la ubicación prevista, que el contenido original siga funcionando y que el juego avise cuando encuentre datos no admitidos en vez de cambiarlos sin avisar. Separa esos resultados de las recomendaciones de diseño y de las ilustraciones conceptuales.
Preguntas frecuentes
¿Qué debe controlar un editor de escenarios de combate personalizados?
Empieza por las opciones de diseño que el juego ya admite: los límites de la arena, el punto de inicio del jugador, los grupos de aparición de enemigos, los tiempos de espera de las oleadas, el presupuesto de recursos y una condición de victoria. Deja el comportamiento de las armas y la IA de los enemigos fuera del editor, salvo que esos sistemas ya ofrezcan parámetros que puedan modificarse con seguridad.
¿Debe un editor de escenarios guardar los datos en JSON o como recursos del motor?
Elige el formato que encaje con el proyecto y con la forma de crear los escenarios. Godot documenta los Resources personalizados como recursos de datos editables. Su tutorial de guardado usa JSON para estados de ejecución sencillos y explica sus limitaciones. Unity describe ScriptableObject como un contenedor de datos del proyecto que, por sí solo, no constituye un sistema de guardado durante la ejecución.
¿Cómo puedo impedir que se inicien arenas personalizadas no válidas?
Valida los campos obligatorios antes de la vista previa. Comprueba que la arena sea conocida, que el punto de inicio del jugador esté dentro de sus límites, que haya al menos un grupo de aparición válido, que los tiempos de espera no sean negativos, que se reconozcan los ID de enemigos y que haya una salida alcanzable o una condición de victoria que se pueda cumplir. Señala el campo que hay que revisar en vez de descartarlo sin avisar.
¿Cómo mantengo el funcionamiento de mi shooter al añadir un editor?
Haz que el editor se limite a producir los datos del escenario y que los sistemas de combate actuales los reciban a través de un punto de entrada bien delimitado. Conserva el movimiento, las armas, el comportamiento de los enemigos y la carga de la campaña. Revisa los cambios archivo por archivo antes de aceptar las modificaciones de la IA.
¿Qué debo probar antes de compartir un escenario personalizado?
Prueba un escenario incluido en el juego, un escenario personalizado válido, campos ausentes o no válidos, una arena deliberadamente estrecha y varios reinicios. Anota la versión del proyecto y los pasos. Una vista previa visual por sí sola no demuestra que el combate esté equilibrado ni que se pueda completar.
Amplía el editor cuando el flujo de datos sea estable
Empieza con una arena y unos pocos valores admitidos. Añade opciones de colocación más completas o funciones para compartir escenarios solo cuando los datos de escenario, la validación y la carga durante la ejecución sigan un flujo estable. Así, la función será más fácil de entender y de revertir, y habrá menos probabilidades de que cambie la sensación de juego del shooter.
Si tienes una idea para un prototipo independiente que se pueda jugar en el navegador, prueba SEELE AI Game Maker. La invitación es a crear un prototipo independiente y se refiere únicamente a ese uso.


