RTS Terrain Studio

Cómo se construye un mapa

Si has usado el editor de mapas de un RTS clásico, la mayoría de estas ideas te resultarán familiares. Un mapa es una cuadrícula de celdas cuadradas (de 2 m de ancho de forma predeterminada). Las esquinas de las celdas son los vértices, y la mayoría de los datos se guardan por vértice o en texturas de alta resolución que cubren el mapa.

En una escena, un mapa se encuentra en un GameObject con el componente RTSTerrain. El menú GameObject ▸ RTS Terrain Studio ▸ RTS Terrain también le añade los componentes de los subsistemas (RTSVegetationRenderer, RTSWaterRenderer y RTSDecorManager). El terreno lee el mapa de un archivo .rtsmap de tu proyecto (un RTSMapAsset). Los meshes de los chunks (bloques de celdas), la hierba y el agua que muestra se generan a partir de ese archivo. Nunca se guardan en la escena, así que tus escenas siguen siendo pequeñas.

Tus primeros cinco minutos

Es la forma más rápida de ver todo en funcionamiento. No necesitas configurar nada más que importar el paquete.

1. Abre Tools ▸ RTS Terrain Studio ▸ Validate Project y haz clic en Fix All. Esto configura URP, la renderer feature de la niebla de guerra, las texturas de cámara que usa el agua y el espacio de color. Antes de cambiar nada, un cuadro de diálogo de confirmación te explica los cambios.
2. Ejecuta Tools ▸ RTS Terrain Studio ▸ Create Demo Content. Aparece una barra de progreso mientras se generan texturas, modelos, tilesets, mapas y escenas. Cuando termina, la escena RTS Terrain Studio - Gameplay Demo queda seleccionada en la ventana Project.
3. Haz doble clic en esa escena para abrirla y después presiona Play.
4. Selecciona tus unidades con el botón izquierdo del ratón (haz clic o arrastra un rectángulo) y haz clic con el botón derecho en el suelo para moverlas. Desplaza la cámara con WASD o las teclas de flecha, acerca y aleja con la rueda del ratón, y presiona F1 para ver todos los controles.
5. Detén el modo Play y abre la escena RTS Terrain Studio - Editor Playground. Abre Tools ▸ RTS Terrain Studio ▸ Editor Window, elige una herramienta y pinta en la Scene View. Mantén presionada Shift para hacer lo contrario (por ejemplo, bajar en lugar de subir). Presiona Ctrl+Z para deshacer.
6. Abre la escena RTS Terrain Studio - In-Game Editor Demo y presiona Play. Este es el editor que reciben tus jugadores. Presiona F5 para probar el mapa en el juego con unidades, y F2 para mostrar u ocultar el editor.

Por dónde empezar

Características

Cada herramienta de edición que aparece a continuación existe tanto en el Unity Editor como en el editor en el juego, porque ambos usan las mismas clases de herramienta (subclases de RTSTool). Los nombres de esta lista son los que ves en la interfaz de usuario.

Decisiones de diseño de un vistazo

Estas son las preguntas más frecuentes sobre las herramientas de terreno para RTS y cómo las resuelve RTS Terrain Studio.

Un primer vistazo a la API

Para que los programadores se hagan una idea de la API, aquí tienes un script completo. Consulta al terreno sobre el punto en el que haces clic y planifica una ruta hasta él con el buscador de rutas integrado. No necesita colliders ni componentes adicionales: añádelo a cualquier GameObject de una escena que tenga un RTSTerrain.

using System.Collections.Generic;
using RTSTerrainStudio;
using UnityEngine;

/// <summary>Click on the ground: logs what the terrain knows about that point and plans a path to it.</summary>
public class ClickInfoExample : MonoBehaviour
{
    // Reused for every click, so no new list is allocated each time.
    readonly List<Vector3> path = new List<Vector3>();

    void Update()
    {
        // RTSInput works with the Input System package and with the old Input Manager.
        if (!RTSInput.GetMouseButtonDown(0) || Camera.main == null) return;

        Ray ray = Camera.main.ScreenPointToRay(RTSInput.PointerPosition);

        // Analytic ray cast against every RTSTerrain in the scene. Colliders are not needed.
        if (!RTSTerrain.RaycastAll(ray, out RTSTerrainHit hit)) return;
        RTSTerrain terrain = hit.terrain;

        // Gameplay questions, answered from the map data and the pathing map.
        int level = terrain.GetCliffLevel(hit.point);
        bool buildable = terrain.IsBuildable(hit.point);
        bool water = terrain.IsWater(hit.point, out float depth);
        Debug.Log($"Cell {hit.cell}: cliff level {level}, buildable {buildable}, water {water} ({depth:0.00} m)");

        // Built-in Burst A* on the pathing map, for a unit with a radius of 0.6 m.
        PathStatus status = RTSPathfinder.FindPath(terrain, transform.position, hit.point,
                                                   PathRequestOptions.ForUnit(0.6f), path);
        Debug.Log($"Path from {name}: {status}, {path.Count} waypoints");
    }
}

PathStatus puede ser Success, Partial (el punto alcanzable más cercano), NoPath o InvalidStart. El capítulo Guía de scripting explica toda la API.

Requisitos

Estructura de carpetas

El paquete está en una sola carpeta, de forma predeterminada Assets/RTSTerrainStudio. Puedes mover o renombrar esta carpeta: el editor encuentra la raíz del paquete a partir de la ubicación de RTSTerrainStudio.Runtime.asmdef, y el contenido de demostración y la documentación se localizan en relación con ella.

RTSTerrainStudio/
├── Runtime/                 Core, rendering, tools and runtime systems (RTSTerrainStudio.Runtime)
├── Editor/                  Editor window, Scene View, inspectors, setup, demo content (RTSTerrainStudio.Editor)
├── Shaders/                 URP shaders and HLSL includes
│   ├── Hidden/              Internal shaders (fog blur, minimap fog, gizmos, texture array blit)
│   └── Include/             Shared HLSL (fog of war, brush cursor, wind, terrain, vegetation, water)
├── Samples/
│   ├── Scripts/             Sample gameplay: camera, units, selection, orders, minimap, HUD (RTSTerrainStudio.Samples)
│   └── Scenes/              Demo scenes (created by Create Demo Content)
├── Integrations/
│   ├── Mirror/              Multiplayer (compiled only with Mirror)
│   ├── AStarPathfinding/    A* Pathfinding Project (compiled only with A* Pro 5.4.4+)
│   └── UnityNavMesh/        Unity AI Navigation (compiled only with com.unity.ai.navigation 2.0+)
├── Content/                 Generated demo content (empty until you run Create Demo Content)
├── Resources/
│   └── RTSTerrainStudio/    Runtime UI style sheets and theme, shader references, panel settings
├── Documentation/           This manual (index.html) and its images
└── Tests/
    └── Editor/              EditMode unit tests (RTSTerrainStudio.Tests.Editor)

Qué incluye

El paquete se distribuye como código fuente, shaders y este manual. Todo lo visual (texturas, modelos, tilesets, mapas y escenas) lo genera un script en tu equipo. Así la descarga es pequeña y el contenido tiene exactamente la misma licencia que el código.

Mapas de demostración

Los tres mapas usan celdas de 2 m, una altura de nivel de acantilado de 2 m y el tileset Summer.

Mapa	Tamaño	Simetría	Descripción
Two Rivers (1v1).rtsmap	128 × 128 celdas	Rotate 2	Dos jugadores, dos ríos. Los ríos se pueden cruzar por vados poco profundos en cualquier punto, y el lago central es profundo. Las rampas suben a mesetas boscosas con ruinas y campamentos abandonados.
Four Kingdoms (4p).rtsmap	192 × 192 celdas	Rotate 4	Cuatro reinos, cada uno en sus propias tierras altas. Las rampas bajan a las tierras bajas compartidas, y el centro es tierra corrupta con las ruinas de un antiguo templo.
Sandbox.rtsmap	96 × 96 celdas	None	Un mapa pequeño y mayormente llano para probar las herramientas.

Iconos

RTSIcons dibuja de forma procedural todos los iconos de la ventana del editor, de los inspectores y del editor en el juego, así que se mantienen nítidos a cualquier tamaño y funcionan en las builds sin assets de textura.

Instalación y configuración

Abrir las escenas de demostración

Las escenas de demostración están en RTSTerrainStudio/Samples/Scenes. Abre una haciendo doble clic en ella en la ventana Project, o elígela en el paso 3 de la ventana Welcome y haz clic en Open.

Tu primer mapa

Un mapa se aloja en un GameObject RTS Terrain de tu escena y se guarda en un archivo .rtsmap de tu proyecto. La escena solo hace referencia al archivo; tus ediciones se guardan en el archivo. Empieza con una escena nueva para poder experimentar libremente:

1. Elige File ▸ New Scene y selecciona una plantilla de escena de URP (por ejemplo, Basic (URP)).
2. Guarda la escena enseguida con Ctrl+S, por ejemplo, como Assets/MyMaps/FirstMap.unity. Los archivos de mapa nuevos se crean junto a la escena guardada, así tu mapa y tu escena quedan juntos.

Abrir la ventana del editor

Abre Tools ▸ RTS Terrain Studio ▸ Editor Window (el asistente y la ventana Welcome pueden abrirla por ti, y el Inspector de RTS Terrain tiene un botón Open RTS Terrain Studio). Acóplala junto al Inspector para ver la Scene View al mismo tiempo.

Área	Qué muestra
Cabecera	Selector de terreno, nombre del mapa (un punto indica cambios sin guardar), Save, Save As…, Open…, Reload, Undo / Redo con el nombre del paso, un botón de ayuda y el interruptor Editing On / Editing Off.
Barra de pestañas	Ocho categorías de herramientas (Height, Cliffs, Paint, Vegetation, Decor, Water, Pathing, Markers), seguidas de Map y Settings. Un punto marca la categoría de la herramienta activa.
Página de herramientas	Botones grandes de herramientas, una tarjeta que describe la herramienta activa con su estado en tiempo real, las tarjetas Brush y Symmetry, y los ajustes y paletas propios de la herramienta (capas, niveles de acantilado, jugadores, árboles, decoración).
Barra de estado	La celda, el nivel de acantilado, la altura y el pathing bajo el cursor, y la memoria que ocupa el historial de deshacer.

Las ocho categorías y sus herramientas:

Tecla	Categoría	Herramientas
1	Height	Raise / Lower, Smooth, Flatten, Set Height, Noise, Terrace, Erode
2	Cliffs	Raise / Lower Level, Set Level, Ramp, Cliff Type, Clean Cliffs
3	Paint	Paint Layer, Tile Paint, Fill / Replace, Smooth Paint, Auto Paint
4	Vegetation	Paint Details, Erase Details, Place Trees, Erase Trees
5	Decor	Place Decor, Erase Decor, Select Decor
6	Water	Paint Water, Erase Water, Flood Fill
7	Pathing	Paint Pathing, Clear Pathing
8	Markers	Start Locations, Regions, Markers

Cada herramienta se describe en detalle en su propio capítulo (por ejemplo, Herramientas de altura y Herramientas de acantilado); la ventana en sí se describe en Ventana del editor.

Tu primera prueba de juego

Hay dos formas de jugar tu mapa: con el Demo Game en el modo Play, o dentro del juego en ejecución con el editor en el juego y su botón Play Test.

using RTSTerrainStudio;
using UnityEngine;

// Add this component to any GameObject in a scene with an RTS Terrain and an in-game editor.
public class PlaytestStartLogger : MonoBehaviour
{
    void OnEnable()
    {
        // Raised by the in-game editor when a play test starts (true) or stops (false).
        RTSRuntimeEditorEvents.PlaytestChanged += OnPlaytestChanged;
    }

    void OnDisable()
    {
        RTSRuntimeEditorEvents.PlaytestChanged -= OnPlaytestChanged;
    }

    void OnPlaytestChanged(bool playing)
    {
        if (!playing) return;

        // The first enabled terrain of the scene.
        RTSTerrain terrain = RTSTerrain.Main;
        if (terrain == null || terrain.Map == null) return;

        foreach (StartLocation start in terrain.Map.StartLocations)
        {
            // Start locations are stored in map-local coordinates: convert to world space
            // and move the point onto the ground.
            var local = new Vector3(start.position.x, start.position.y, start.position.z);
            Vector3 world = terrain.SnapToGround(terrain.LocalToWorld(local));
            Debug.Log($"Player {start.player + 1} starts at {world}, facing {start.yaw:0} degrees");
        }
    }
}

Tutorial de 10 minutos: tu primer mapa 1v1

En este tutorial crearás un mapa pequeño y equilibrado para dos jugadores: cada jugador tiene una base sobre una meseta con una rampa, un río separa las dos mitades y los bosques enmarcan el mapa. El pintado simétrico garantiza que ambos lados sean idénticos, así que solo tienes que construir una mitad.

Próximos pasos

• Ventana del editor: cada pestaña, tarjeta y ajuste en detalle, incluida la pestaña Map (cambio de tamaño, generador, importación y exportación de mapas de alturas, minimapa, entorno).
• Los capítulos de herramientas, uno por categoría: Height, Cliffs, Paint, Vegetation, Decor, Water, Pathing, Markers.
• Editor en el juego: publica el editor con tu juego y deja que los jugadores creen mapas.
• Scripting: consulta alturas, niveles de acantilado y pathing desde código, carga mapas en tiempo de ejecución y reacciona a las ediciones.
• Integraciones: multijugador con Mirror, búsqueda de rutas con el A* Pathfinding Project o Unity NavMesh.
• Solución de problemas: materiales rosas, agua plana, desfases al pintar y otros problemas comunes.

El Project Validator

Abre Tools ▸ RTS Terrain Studio ▸ Validate Project o haz clic en Validate en la ventana Welcome. Las comprobaciones se ejecutan en cuanto se abre la ventana. Se agrupan en cinco categorías:

Cada resultado tiene uno de estos cuatro estados:

Fix All aplica todas las correcciones disponibles. Primero, un cuadro de diálogo enumera todos los cambios, y no se modifica nada hasta que haces clic en Apply Fixes. Las correcciones que necesitan URP (las texturas de cámara y la renderer feature de niebla de guerra) se ejecutan automáticamente después de asignar el pipeline, así que un solo clic configura un proyecto nuevo. Run Again repite las comprobaciones. La lista completa de comprobaciones, con sus botones de corrección, está en Validar el proyecto.

Ejecutar las comprobaciones desde código

RTSProjectValidator.RunChecks() devuelve los resultados sin cambiar nada, y RTSProjectValidator.FixAll() aplica las correcciones. Puedes usarlos en un script de compilación o en una tarea de integración continua. El ejemplo debe colocarse en una carpeta Editor.

using UnityEditor;
using UnityEngine;
using RTSTerrainStudio.Editor;

// Command line: Unity -batchmode -projectPath <path> -executeMethod ProjectSetupCheck.Run -quit
public static class ProjectSetupCheck
{
    public static void Run()
    {
        // Runs every check. Nothing is modified.
        var results = RTSProjectValidator.RunChecks();

        // Applies every available fix without dialogs, then checks again.
        int applied = RTSProjectValidator.FixAll(results, interactive: false);
        if (applied > 0) results = RTSProjectValidator.RunChecks();

        // Logs warnings and errors ("[Status] Title: Message").
        foreach (var result in results)
            if (result.IsProblem) Debug.LogWarning(result.ToString());

        // Fails the job when a required setting is still missing.
        if (RTSProjectValidator.WorstStatus(results) == RTSValidationStatus.Error)
            EditorApplication.Exit(1);
    }
}

Universal Render Pipeline

Todos los shaders del paquete están escritos para URP. Sin él, el terreno, el agua y la vegetación se renderizan en rosa o no se renderizan en absoluto. La corrección Use URP toma un asset de URP del proyecto (o crea Assets/Settings/RTS URP.asset con un renderer) y lo asigna como pipeline de renderizado predeterminado y a cada nivel de calidad que use otro pipeline. Para hacer lo mismo a mano:

1. Si el proyecto aún no tiene un asset de URP, crea uno en la ventana Project con Create ▸ Rendering ▸ URP Asset (with Universal Renderer).
2. Asígnalo en Edit ▸ Project Settings ▸ Graphics como Default Render Pipeline.
3. Abre Edit ▸ Project Settings ▸ Quality. Para cada nivel de calidad que sobrescriba el pipeline con su propio Render Pipeline Asset, comprueba que también sea un asset de URP.

Depth Texture y Opaque Texture

El agua usa la textura de profundidad de la cámara para que su color de profundidad, la espuma y la orilla suave se adapten a los objetos que hay dentro del agua, y la textura opaca, para la refracción. Sin ellas, el agua se ve más simple. Selecciona cada asset de URP que usen tus niveles de calidad y marca Depth Texture y Opaque Texture en su sección Rendering, o haz clic en Enable Both en el validador.

La renderer feature de niebla de guerra

La renderer feature RTS Fog Of War (RTSFogOfWarRendererFeature) dibuja la niebla de guerra sobre todo lo que hay en pantalla, incluidas las unidades y los props que usan tus propios materiales. Sin ella, solo los shaders propios del paquete muestran la niebla de guerra. Add Feature la añade al renderer predeterminado de cada asset de URP en uso. Para añadirla a mano, selecciona el asset Universal Renderer Data, haz clic en Add Renderer Feature y elige RTS Fog Of War. Encontrarás los detalles en Renderizado: renderer feature y respaldo en los shaders.

Espacio de color

El paquete está diseñado para el espacio de color Linear, el predeterminado de URP. En el espacio Gamma, los colores, la iluminación y el agua se ven desvaídos en comparación con las capturas de pantalla. Establece Edit ▸ Project Settings ▸ Player ▸ Other Settings ▸ Color Space en Linear o haz clic en Switch to Linear en el validador.

Paquetes necesarios

El ensamblado de tiempo de ejecución usa Burst (com.unity.burst), Collections (com.unity.collections) y Mathematics (com.unity.mathematics) para sus jobs y su modelo de datos. Los scripts del paquete no compilan mientras falte alguno de ellos. Instálalos desde Window ▸ Package Manager ▸ Unity Registry o haz clic en Install en el validador, que añade todos los paquetes que faltan con una sola solicitud del Package Manager. Las versiones probadas se indican en Paquetes necesarios.

Gestión de entrada

Toda la entrada en tiempo de ejecución (el editor en el juego, la cámara y las unidades de ejemplo) pasa por la clase estática RTSInput. Cuando el paquete Input System (com.unity.inputsystem) está instalado, el ensamblado de tiempo de ejecución se compila con el símbolo de compilación RTS_INPUT_SYSTEM y usa el Input System. En caso contrario, o cuando el proyecto solo usa el antiguo Input Manager, RTSInput recurre a la antigua API UnityEngine.Input.

El ajuste está en Edit ▸ Project Settings ▸ Player ▸ Other Settings ▸ Active Input Handling. Unity pide reiniciar el editor cuando lo cambias. La comprobación Input handling nunca cambia el ajuste por ti, porque depende de tu juego. Consulta también Gestión de entrada en los requisitos.

Shaders y contenido

• Package shaders compile. Si un shader del paquete tiene errores de compilación (los objetos afectados se renderizan en rosa), Reimport lo vuelve a importar. Esto ayuda cuando los shaders se importaron antes de que URP terminara de cargarse. Si faltan por completo algunos shaders necesarios, vuelve a importar el paquete desde la Asset Store. Consulta Solución de problemas.
• Shaders included in builds. Consulta Compilar tu juego.
• Tileset texture arrays built. Los tilesets sin arrays generados y actualizados siguen funcionando, pero hasta que se vuelvan a generar los arrays, el editor genera arrays sin comprimir al cargar el mapa, lo que consume memoria y alarga el tiempo de carga. Build Arrays los genera para cada tileset desactualizado. Al compilar el juego, los arrays desactualizados se vuelven a generar automáticamente; los tilesets cuyos arrays nunca se generaron también usan arrays sin comprimir en el juego compilado. Consulta Arrays de texturas y Arrays de texturas en las builds del juego.
• GPU instancing on instanced prototypes. Los materiales de los árboles instanciados, de los detalles en modo Mesh y de la decoración instanciada deberían tener marcada la opción Enable GPU Instancing. De lo contrario, se dibujan mediante copias temporales, y sus variantes de instanciación pueden eliminarse de las builds del juego. Enable Instancing la marca en cada material de la lista que se pueda editar. Los materiales que están dentro de un modelo o de un paquete son de solo lectura: extráelos primero. Consulta Instanciación por GPU.
• Terrains have a tileset. Un terreno sin tileset muestra un aspecto neutro provisional. La corrección asigna un tileset del proyecto a cada terreno que no tenga uno (se puede deshacer). Consulta Tilesets.

Archivos de mapa para los terrenos de la escena

Un RTS Terrain guarda su mapa en un asset .rtsmap (su campo Map Asset). Un terreno sin él tiene su mapa solo en memoria, y tus ediciones se pierden al cerrar la escena. La comprobación Terrains save to a map file enumera estos terrenos. Create Map Files guarda el mapa actual de cada terreno de la lista en un nuevo archivo .rtsmap en la carpeta de su escena (o en Assets/Maps si la escena aún no se ha guardado) y se lo asigna al terreno.

Los terrenos creados con el New Map Wizard o con el contenido de demostración ya tienen un archivo de mapa. Para saber cómo funcionan los assets de mapa, Save y Save As, lee Assets de mapa y archivos de mapa.

Compilar tu juego

Unity solo incluye shaders en una build del juego cuando un material de la build los usa. RTS Terrain Studio crea los materiales del terreno, el agua y la niebla de guerra desde código en tiempo de ejecución, por lo que los shaders se referencian desde el asset Resources/RTSTerrainStudio/RTSShaderReferences.asset dentro de la carpeta del paquete. El asset también referencia el material DecorPlaceholder, que mantiene en la build las variantes de instanciación de URP Lit. Este asset se comprueba y se actualiza automáticamente después de cada recarga de scripts, cada vez que se importan shaders y antes de cada build del juego. Si la comprobación Shaders included in builds está en rojo, haz clic en Update.

Antes de compilar, repasa esta lista:

1. Ejecuta Tools ▸ RTS Terrain Studio ▸ Validate Project y corrige todos los errores y advertencias.
2. Comprueba que cada nivel de calidad de tu plataforma de destino use un asset de URP con Depth Texture y Opaque Texture, y que su renderer tenga la feature RTS Fog Of War si usas niebla de guerra.
3. Genera una vez los arrays de texturas de tus tilesets (Build Arrays en el validador o Build Texture Arrays en el Inspector del tileset), para que el terreno no los genere sin comprimir durante la carga. Los arrays desactualizados se vuelven a generar automáticamente antes de cada build del juego (consulta más abajo).
4. Si tus mapas usan niebla atmosférica, asegúrate de que la comprobación Fog kept in player builds esté en OK (consulta Niebla en las builds del juego).
5. Valida tus mapas en la pestaña Map (consulta Validación de mapas).
6. Añade tus escenas a la lista de escenas de tu perfil de build. Los mapas asignados a un RTS Terrain de una escena se incluyen como cualquier otro asset referenciado.
7. Si publicas el editor en el juego, lee Publicar el editor en el juego. Los mapas que los jugadores guardan en tiempo de ejecución van a la carpeta Maps de RTSMapSerializer.StorageRoot (Application.persistentDataPath y, en las builds web, el almacenamiento del navegador); consulta Archivos de mapa en tiempo de ejecución.
8. Si subes el Managed Stripping Level por encima de Minimal y has escrito tus propias herramientas de edición, lee Eliminación de código y herramientas personalizadas.
9. Para una build web, lee también Builds web (WebGL).

Arrays de texturas en las builds del juego

Una build del juego usa los arrays de texturas generados de un tileset tal como están, porque solo el editor puede compararlos con las texturas de origen. Para que una build nunca se publique con texturas de suelo antiguas, justo antes de que empiece una build del juego se comprueba cada tileset cuyos arrays ya se generaron alguna vez:

• Los arrays que ya no coinciden con las texturas, la resolución o la compresión, o que se generaron para otra plataforma u otra compresión de texturas, se vuelven a generar con calidad de compresión normal. Una barra de progreso muestra el avance.
• Los tilesets cuyos arrays nunca se generaron no se tocan. El juego compilado genera para ellos arrays sin comprimir al cargar un mapa.
• Si se cancela o falla una regeneración y las texturas o los ajustes han cambiado, un cuadro de diálogo ofrece Try Again, Cancel Build y Build Anyway. Los arrays que solo usan otro formato siguen mostrando las texturas correctas, así que para ellos solo se registra una advertencia.
• En ese caso, una build en modo batch se detiene. Añade -rtsAllowOutdatedTextureArrays a la línea de comandos para compilar de todos modos, con una advertencia por tileset.
• Un editor sin dispositivo gráfico (-nographics, habitual en los servidores de compilación) no puede generar arrays. En ese caso, la build continúa con una advertencia por cada tileset desactualizado, y el juego compilado usa los arrays tal como se generaron la última vez. Genera los arrays en el editor antes de una build así.
• Los arrays solo se vuelven a generar para la plataforma de build activa. Si compilas para otra plataforma, la build registra una advertencia en su lugar: cambia primero a esa plataforma.
• Los asset bundles y el contenido de Addressables que compilas por separado no ejecutan esta comprobación. Genera antes los arrays.

Los arrays generados se guardan en el asset del tileset con lectura habilitada (readable). El juego compilado libera esta copia en la CPU la primera vez que se usan los arrays, lo que ahorra unos 14 MB por tileset a 512 px y unos 56 MB a 1024 px.

Niebla en las builds del juego

RTSEnvironment activa la niebla atmosférica guardada en un mapa mientras el juego se ejecuta. Unity elimina las variantes de shader de los modos de niebla que cree que no se usan: con Project Settings ▸ Graphics ▸ Shader Stripping ▸ Fog Modes en Automatic, solo conserva la niebla de las escenas de la build que se guardaron con la niebla activada. RTS Environment restaura la niebla propia de la escena antes de cada guardado, así que su niebla no cuenta, y los mapas con niebla no mostrarían ninguna niebla en una build.

La comprobación Fog kept in player builds lee las escenas de la build del perfil de build activo y las escenas abiertas, y enumera los modos de niebla que RTS Environment usa en ellas. Keep Fog Modes (que también forma parte de Fix All) establece Fog Modes en Custom y conserva exactamente esos modos, además de los que ya se conservaban. Cada modo conservado añade variantes de shader a la build, por lo que no se añaden los modos que no se usan. Si el perfil de build activo sobrescribe los ajustes de Graphics, comprueba también su ajuste Fog Modes.

Builds web (WebGL)

RTS Terrain Studio funciona en un navegador web: el terreno, la vegetación, el agua, la decoración, la niebla de guerra, el editor en el juego y los ejemplos. Sin embargo, un navegador funciona de forma distinta a un equipo de escritorio: no hay ninguna carpeta que el jugador pueda abrir, algunas teclas pertenecen al navegador, todo el código se ejecuta en un solo hilo y todo el juego comparte un único heap de memoria de tamaño limitado. Esta sección explica qué hace el paquete al respecto y cómo compilar, probar y publicar una build web.

En resumen:

1. Abre File ▸ Build Profiles, selecciona Web y haz clic en Switch Platform (o convierte tu perfil de build para Web en el perfil activo).
2. Ejecuta Tools ▸ RTS Terrain Studio ▸ Validate Project y haz clic en Fix All. Con Web activa, el validador también instala la plantilla de ventana completa y comprueba los niveles de calidad de las builds web.
3. Si tus mapas usan niebla atmosférica, asegúrate de que la comprobación Fog kept in player builds esté en OK.
4. Haz clic en Build And Run. Unity compila el juego y lo abre en tu navegador.

using RTSTerrainStudio;
using UnityEngine.Scripting;

// [Preserve] keeps the tool in builds with a high Managed Stripping Level.
[Preserve]
public sealed class CraterTool : RTSTool
{
    // ...
}

using System.IO;
using RTSTerrainStudio;

public static class MyGameFiles
{
    // Kept between sessions on every platform; in Web builds in the storage of the browser.
    static string SettingsPath => Path.Combine(RTSMapSerializer.StorageRoot, "settings.json");

    public static void SaveSettings(string json)
    {
        Directory.CreateDirectory(RTSMapSerializer.StorageRoot);
        File.WriteAllText(SettingsPath, json);

        // Web builds: write the change to the browser storage, so it survives a reload.
        // Does nothing on other platforms.
        RTSWebFileSystem.Flush();
    }

    /// <summary>Lets the player keep a copy of the current map on the computer (Web builds only).</summary>
    public static bool DownloadMap(RTSTerrain terrain)
    {
        if (!RTSWebFileSystem.IsSupported || terrain.Map == null) return false;
        byte[] bytes = RTSMapSerializer.Serialize(terrain.Map);
        return RTSWebFileSystem.DownloadFile("My Map" + RTSMapSerializer.FileExtension, bytes);
    }
}

El modelo de mapa

Todos los datos del mapa residen en un único objeto de la clase MapData (espacio de nombres RTSTerrainStudio). Un componente RTSTerrain posee un MapData (terrain.Map), lo renderiza como meshes de chunks, mantiene actualizado el mapa de pathing derivado y responde a consultas como «¿a qué altura está el suelo aquí?».

Celdas y vértices

El mapa es una cuadrícula de Width × Height celdas. Cada celda tiene cuatro vértices en sus esquinas, y las celdas vecinas comparten esquinas. Por eso, un mapa de 4 × 2 celdas tiene 5 × 3 vértices:

 z
 2   v10 ---- v11 ---- v12 ---- v13 ---- v14
      |  cell  |  cell  |  cell  |  cell  |
      | (0,1)  | (1,1)  | (2,1)  | (3,1)  |
 1   v5 ----- v6 ----- v7 ----- v8 ----- v9
      |  cell  |  cell  |  cell  |  cell  |
      | (0,0)  | (1,0)  | (2,0)  | (3,0)  |
 0   v0 ----- v1 ----- v2 ----- v3 ----- v4
     x=0      1        2        3        4

 vertex index = z * VertexCountX + x      (VertexCountX = Width + 1)

• Las capas por vértice (altura fina, nivel de acantilado, indicadores, tipo de acantilado, altura del agua) tienen (Width + 1) × (Height + 1) entradas, guardadas fila a fila. Usa map.VertexIndex(x, z).
• El tamaño de celda (map.CellSize, predeterminado: 2 m) es el tamaño de una celda en el mundo. Un mapa de 128 × 128 con celdas de 2 m cubre 256 × 256 m (map.WorldSize).
• Una posición pertenece a la celda floor(localXZ / CellSize); map.LocalToCell(localXZ) hace este cálculo y limita el resultado al mapa.
• Para el renderizado, las celdas se agrupan en chunks (bloques de 16, 32 o 64 celdas por lado; ajuste Chunk Size del componente RTSTerrain, predeterminado: 32). Solo se reconstruyen los chunks afectados por una edición. El tamaño de chunk no cambia los datos del mapa.

Dimensiones del mapa

Las dimensiones se eligen al crear un mapa (con el New Map Wizard, el cuadro de diálogo New Map del editor en el juego o MapCreationSettings desde código). MapCreationSettings.Validate() corrige los valores que quedan fuera del rango válido.

Qué contiene un mapa

Cada tipo de datos tiene un indicador correspondiente en el enum MapLayers. Los indicadores se usan para las notificaciones de cambios, el registro de los pasos de deshacer y la serialización.

Hay dos indicadores combinados muy útiles: MapLayers.Geometry (alturas, niveles, indicadores de vértice, tipos de acantilado) y MapLayers.PathingInputs (todo lo que influye en el mapa de pathing). MapLayers.All lo abarca todo.

El mapa de pathing (terrain.Pathing, clase PathingMap) está formado por datos derivados: se calcula a partir de las capas anteriores y nunca se guarda. Consulta Mapa de pathing.

Niveles de acantilado, alturas finas y tipos de acantilado

El terreno de los RTS clásicos tiene dos tipos de altura: grandes escalones discretos (acantilados) y pequeñas variaciones suaves (colinas). RTS Terrain Studio guarda ambos por separado en cada vértice.

Niveles de acantilado

• Cada vértice tiene un nivel de acantilado de 0 a 15 (MapData.MaxCliffLevel = 15).
• Un nivel mide CliffLevelHeight metros de alto (predeterminado: 2 m).
• Los mapas nuevos empiezan en el nivel 2, así que hay dos niveles por debajo del suelo para lagos, ríos y cañones, y trece por encima para mesetas.
• Edita los niveles con las herramientas de acantilado: Raise / Lower Level, Set Level, Ramp, Cliff Type y Clean Cliffs.
• La niebla de guerra usa los niveles de acantilado para la línea de visión: las unidades ven su propio nivel y los inferiores; el terreno más alto les bloquea la visión.

Alturas finas

Además del nivel, cada vértice tiene una altura fina en metros (Heights), positiva o negativa. Las herramientas de altura (Raise / Lower, Smooth, Flatten, Set Height, Noise, Terrace, Erode) solo cambian la altura fina, así que puedes crear colinas sobre una meseta sin convertirlas en acantilados. La altura del suelo de un vértice es:

vertex height = CliffLevels[i] × CliffLevelHeight + Heights[i]      (map-local Y, metres)

Ejemplo: el nivel 3 con una altura de nivel de 2 m y una altura fina de 0.4 m da un vértice situado 6.4 m por encima del origen del mapa. map.GetVertexHeight(x, z) y map.GetVertexPosition(x, z) lo calculan por ti.

Tipos de acantilado

Un tileset puede tener hasta 4 capas de acantilado (por ejemplo, «Rock» y «Grassy Cliff»). Cada vértice guarda cuál debe usar (CliffTypes, 0–3; se pinta con la herramienta Cliff Type). Una pared de acantilado usa el tipo de acantilado de la esquina más alta de su celda. Si un índice de tipo de acantilado no tiene capa en el tileset, la pared recurre a la capa de acantilado 0.

Cómo se construye la superficie (la superficie de referencia)

El struct MapGeometryView define la única superficie real del terreno. Los meshes de los chunks, las consultas de jugabilidad (GetHeight, Raycast, …), el mapa de pathing y la niebla de guerra siguen las mismas reglas, así que lo que ves es exactamente por donde caminan las unidades. Cada celda se clasifica según sus cuatro esquinas:

Contornos redondeados. Dentro de una celda de acantilado, para cada umbral de nivel t se interpola bilinealmente sobre toda la celda la función indicadora «nivel de la esquina ≥ t» (1 o 0). Un punto pertenece al nivel más alto cuyo valor indicador interpolado sea al menos 0.5 (MapGeometryView.LevelAt). Es una regla de tipo marching squares: una sola esquina elevada produce un cuarto de círculo en lugar de una diagonal, y las líneas de acantilado largas se mantienen rectas. La pared en sí es vertical en el contorno. Las alturas finas siempre se interpolan bilinealmente y se suman encima, también dentro de las celdas de acantilado.

El aspecto de las paredes renderizadas se ajusta en el componente RTSTerrain (Settings):

Obtén una vista con map.GetGeometryView(). Es un struct de arrays nativos, así que también puedes pasarlo a jobs de Burst. Todos los miembros reciben posiciones en espacio local del mapa:

Rampas

Una rampa permite a las unidades caminar de un nivel de acantilado al siguiente. La regla es sencilla:

• El indicador es VertexFlags.Ramp en cada vértice. La herramienta Ramp (id cliff.ramp) lo pinta; mantén presionada Shift para quitarlo.
• Una celda de rampa es una pendiente bilineal suave entre las alturas de sus esquinas (nivel más altura fina).
• Las rampas funcionan mejor cuando salvan exactamente un nivel. Se permiten rampas más empinadas, pero la barra de estado avisa de las celdas de rampa que abarcan más de un nivel.
• Pathing: en una rampa válida de un nivel, la transitabilidad solo se comprueba con la pendiente de su altura fina (el desnivel entre niveles que salva no la vuelve «demasiado empinada»). Las rampas nunca son edificables.
• En una rampa, GetCliffLevel devuelve el nivel interpolado y redondeado: el nivel inferior en la mitad inferior y el superior en la mitad superior.

1. Eleva una meseta un nivel con Raise / Lower Level.
2. Selecciona la herramienta Ramp y pinta a través del borde del acantilado donde quieras la rampa. Haz que el pincel cubra al menos los vértices de ambos lados de la pared, para que todas las esquinas de las celdas intermedias queden marcadas.
3. La pared desaparece y aparece una pendiente. Ensancha la rampa pintando más vértices a lo largo del borde.

Capas de suelo y splat maps

Las texturas de suelo se pintan en splat maps: cuatro texturas RGBA (MapData.SplatMapCount = 4) de SplatWidth × SplatHeight texels. Cada uno de los 16 canales contiene el peso de una capa de suelo del tileset:

• La capa i se guarda en el splat map i / 4, canal i % 4. Por eso un tileset tiene exactamente 16 capas de suelo: 4 splat maps × 4 canales.
• Los pesos de un texel siempre suman 255 entre los 16 canales. Todas las herramientas de pintura mantienen esta invariante; el código que escriba datos de splat también debe mantenerla.
• La resolución de splat es el número de texels por lado de celda (predeterminado: 4). Con celdas de 2 m, eso equivale a un texel cada 0.5 m.
• El centro del texel (x, z) está en ((x + 0.5), (z + 0.5)) × CellSize / SplatResolution en coordenadas XZ locales del mapa. La misma fórmula se aplica a los texels de detalle y de pathing, con su propia resolución.
• Funciones auxiliares: map.SplatIndex(x, z), map.GetSplatWeight(texelIndex, layer), map.GetDominantLayer(texelIndex), MapData.GetChannel / SetChannel y map.FillSplat(layer).

using RTSTerrainStudio;
using Unity.Mathematics;
using UnityEngine;

public static class SplatExample
{
    /// <summary>Paints one map cell 100 % with a ground layer (like the Tile Paint tool, without undo).</summary>
    public static void PaintCell(RTSTerrain terrain, int2 cell, int layer)
    {
        MapData map = terrain.Map;
        if (map == null || !map.IsValidCell(cell.x, cell.y)) return;
        layer = math.clamp(layer, 0, MapData.MaxGroundLayers - 1);

        int res = map.SplatResolution;
        for (int tz = cell.y * res; tz < (cell.y + 1) * res; tz++)
        {
            for (int tx = cell.x * res; tx < (cell.x + 1) * res; tx++)
            {
                int texel = map.SplatIndex(tx, tz);
                for (int m = 0; m < MapData.SplatMapCount; m++)
                {
                    // All channels 0, except the one of our layer: the sum stays exactly 255.
                    var c = new Color32(0, 0, 0, 0);
                    if (layer / 4 == m) MapData.SetChannel(ref c, layer % 4, 255);
                    map.SplatMaps[m][texel] = c;
                }
            }
        }

        // Tell the terrain which data changed and where (in cells). Textures and pathing update in LateUpdate.
        terrain.NotifyChanged(MapLayers.Splat, new RectInt(cell.x, cell.y, 1, 1));
    }
}

Agua

• Un vértice está bajo el agua cuando tiene el indicador VertexFlags.Water. La altura de la superficie del agua (Y local del mapa, en metros) se guarda en WaterHeights; el valor solo tiene sentido donde el indicador está activo.
• Un punto está mojado cuando la cobertura bilineal de los indicadores de agua de las cuatro esquinas de su celda es de al menos 0.5. Las esquinas sin agua dentro de una celda mojada usan la mayor altura de agua de la celda, así que las orillas se mantienen niveladas.
• Profundidad del agua = superficie del agua − altura del suelo. La profundidad determina el pathing: el agua cuya profundidad supera el Shallow Depth Limit del tileset (predeterminado: 0.9 m) es agua profunda (no transitable); el agua menos profunda es agua poco profunda (transitable y, de forma predeterminada, no edificable).
• Las herramientas de agua son Paint Water, Erase Water y Flood Fill. Las ediciones de agua solo notifican MapLayers.Water, así que los chunks del terreno no se reconstruyen mientras pintas agua.
• Consultas: terrain.IsWater(world, out depth) y terrain.TryGetWaterHeight(world, out waterWorldY).

El aspecto del agua (colores, olas, espuma) procede del perfil de agua del tileset; consulta Perfil de agua.

Densidad de detalles (hierba y plantas pequeñas)

• Los detalles no son objetos individuales. Cada prototipo de detalle que se usa en el mapa tiene un DetailLayer en map.DetailLayers: un byte por texel de detalle (DetailWidth × DetailHeight, predeterminado: 2 texels por lado de celda).
• Una densidad de 0 significa vacío; 255 significa Max Density instancias por texel (un campo del prototipo de detalle, predeterminado: 6). Cada texel genera density / 255 × maxDensity instancias; el renderizador las distribuye de forma determinista, así que el mismo mapa siempre se ve igual.
• Las capas se asocian con la biblioteca de vegetación mediante prototypeId. map.GetOrAddDetailLayer(id) crea una capa cuando hace falta; map.FindDetailLayer(id) devuelve null si el prototipo no se usa.
• Pinta con Paint Details y borra con Erase Details.

Instancias de árboles y decoración

Los árboles (TreeInstanceData) y los objetos decorativos (DecorInstanceData) se guardan como listas simples. En lugar del nombre de un prototipo, cada instancia guarda un pequeño índice de paleta que apunta a una lista de ids de biblioteca del mapa:

map.TreePrototypeIds = [ "a3f0…", "77c1…" ]        <- ids of TreePrototype entries in the vegetation library
map.Trees[n].prototype = 1                          <- this tree uses "77c1…"

• Usa map.GetOrAddTreePrototype(id) / map.GetOrAddDecorPrototype(id) para obtener el índice de paleta de un id de biblioteca (si falta, se añade).
• Como los mapas hacen referencia a los prototipos por su id, puedes renombrar, reordenar o ampliar una biblioteca sin riesgo. Si a la biblioteca le falta un prototipo, el renderizador de vegetación lo omite y el gestor de decoración lo muestra como un cubo sustituto magenta; al añadir un prototipo con el mismo id, vuelve a aparecer. En cuanto al pathing: los árboles cuyo prototipo falta no se dibujan, pero siguen obstruyendo un círculo de PathingMapBuilder.DefaultTreeFootprintRadius (0.8 m) × escala. Los objetos sustitutos de decoración no escriben ninguna huella de pathing hasta que el prototipo vuelve a estar disponible.
• Cada instancia tiene un id único y estable dentro del mapa. Obtén ids nuevos con map.AllocateInstanceId().
• Las posiciones están en coordenadas locales del mapa. Las rotaciones siguen la misma convención en todas partes: grados, en sentido horario visto desde arriba, 0 = +Z, 90 = +X (igual que la rotación Y de Unity).

La convención de position.y

Nunca copies el yOffset del prototipo en position.y: se suma en el momento del renderizado. DecorMath.ComputeLocalPosition y DecorMath.ToStoredHeight convierten entre las posiciones guardadas y las renderizadas.

using RTSTerrainStudio;
using Unity.Mathematics;
using UnityEngine;

public static class InstanceExample
{
    /// <summary>Adds a tree of the first tree prototype of the terrain's vegetation library at a world position.</summary>
    public static uint AddTree(RTSTerrain terrain, Vector3 worldPosition, float yawDegrees)
    {
        MapData map = terrain.Map;
        RTSVegetationLibrary library = terrain.VegetationLibrary;
        if (map == null || library == null || library.trees.Count == 0) return 0;

        Vector3 local = terrain.WorldToLocal(worldPosition);
        var tree = new TreeInstanceData
        {
            id = map.AllocateInstanceId(),
            prototype = map.GetOrAddTreePrototype(library.trees[0].id), // palette index of the library id
            position = new float3(local.x, 0f, local.z),                 // y = offset above the ground, normally 0
            yaw = yawDegrees,                                             // clockwise from above, 0 = +Z
            scale = 1f,
            tint = new Color32(255, 255, 255, 255)
        };
        map.Trees.Add(tree);

        // Notify the cell that changed: vegetation, pathing (tree footprint) and fog blockers update.
        int2 cell = map.LocalToCell(new float2(local.x, local.z));
        terrain.NotifyChanged(MapLayers.Trees, new RectInt(cell.x, cell.y, 1, 1));
        return tree.id;
    }

    /// <summary>Adds a decor object (by library id) standing upright on the ground.</summary>
    public static uint AddDecor(RTSTerrain terrain, string decorPrototypeId, Vector3 worldPosition, float yawDegrees)
    {
        MapData map = terrain.Map;
        if (map == null) return 0;

        Vector3 local = terrain.WorldToLocal(worldPosition);
        var decor = new DecorInstanceData
        {
            id = map.AllocateInstanceId(),
            prototype = map.GetOrAddDecorPrototype(decorPrototypeId),
            variant = 0,                                  // main prefab
            flags = DecorFlags.None,
            position = new float3(local.x, 0f, local.z),  // the prototype's yOffset is added at render time
            rotation = DecorMath.Yaw(yawDegrees),
            scale = new float3(1f, 1f, 1f),
            tint = new Color32(255, 255, 255, 255)
        };
        map.Decor.Add(decor);

        int2 cell = map.LocalToCell(new float2(local.x, local.z));
        terrain.NotifyChanged(MapLayers.Decor, new RectInt(cell.x, cell.y, 1, 1));
        return decor.id;
    }
}

Mapa de pathing

El mapa de pathing responde a las preguntas «¿puede una unidad caminar aquí?» y «¿se puede colocar un edificio aquí?». Es una cuadrícula de celdas de pathing (PathingResolution por lado de celda del mapa; predeterminado: 2, es decir, celdas de pathing de 1 m en un mapa con celdas de 2 m) con un byte PathingFlags por celda. Se deriva automáticamente y se reconstruye de forma incremental cada vez que cambia alguno de sus datos de entrada (geometría, agua, capas de suelo, árboles, decoración, ajustes manuales). Nunca se guarda: solo se guardan los ajustes manuales.

Cómo se derivan los indicadores

1. Terreno: las paredes de acantilado (más el Cliff Margin) establecen Cliff; las pendientes por encima de Max Walkable Slope (predeterminado: 42°) establecen Steep; el agua establece ShallowWater o DeepWater según su profundidad; Flyable se establece en todas partes; Buildable = transitable, pendiente ≤ Max Buildable Slope (predeterminado: 18°) y sin agua (o con agua poco profunda si Shallow Water Buildable está activado). Después se aplica el Pathing Effect de la capa de suelo dominante (por ejemplo, «Unbuildable» en roca rugosa).
2. Huellas: los árboles obstruyen un círculo (Footprint Radius × escala del árbol × Tree Footprint Scale); la decoración aplica su Footprint Effect dentro de un círculo o de un rectángulo girado, salvo que la instancia tenga DecorFlags.IgnorePathing.
3. Los ajustes manuales pintados con Paint Pathing / Clear Pathing se aplican en último lugar.

Los ajustes de las reglas están en el componente RTSTerrain (RTSPathingSettings, propiedad terrain.PathingSettings).

Los mismos indicadores PathingOverride se usan para los efectos de pathing de las capas de suelo, los efectos de huella de la decoración y los ajustes manuales pintados. Consulta el resultado con terrain.GetPathing(world), terrain.IsWalkable(world) y terrain.IsBuildable(world), o lee terrain.Pathing.Flags directamente.

Regiones, posiciones iniciales y marcadores

Son objetos ligeros para la lógica de tu juego. No se renderizan en el juego; los editores los dibujan como gizmos.

Las herramientas guardan position.y = 0 para las posiciones iniciales y los marcadores, y lo tratan como un desplazamiento sobre el suelo, igual que con los árboles.

using RTSTerrainStudio;
using Unity.Mathematics;
using UnityEngine;

public static class RegionExample
{
    /// <summary>Returns the "gold" property of the first region that contains the world position, or 0.</summary>
    public static int GetGoldAt(RTSTerrain terrain, Vector3 worldPosition)
    {
        if (terrain.Map == null) return 0;
        Vector3 local = terrain.WorldToLocal(worldPosition);
        foreach (MapRegion region in terrain.Map.Regions)
        {
            // Regions are rectangles in map-local XZ.
            if (region.Contains(new float2(local.x, local.z)) &&
                int.TryParse(region.GetProperty("gold", "0"), out int gold))
                return gold;
        }
        return 0;
    }
}

Información del mapa y entorno

EnvironmentSettings guarda la iluminación de un mapa. La aplica a la escena un componente RTSEnvironment (GameObject ▸ RTS Terrain Studio ▸ Environment); sin él, los valores se guardan, pero no se usan.

Notificaciones de cambios

Cuando cambies MapData desde código, indica al terreno qué ha cambiado y dónde, en celdas:

• terrain.NotifyChanged(MapLayers layers, RectInt cellRect) lanza MapChanged inmediatamente y pone en cola la reconstrucción.
• terrain.NotifyChangedAll(layers) marca todo el mapa (tras ejecutar un generador o una importación).
• Los cambios pendientes se procesan en LateUpdate (y en cada tick del editor fuera del modo Play) o inmediatamente con terrain.ProcessPendingChanges(). Después se lanza ChangesProcessed: los meshes, las texturas y el pathing ya están actualizados.
• Un vértice toca hasta cuatro celdas. Convierte un rectángulo de vértices con BrushUtility.VertexRectToCellRect(map, vertexRect) y los rectángulos de texels con BrushUtility.TexelRectToCellRect(map, texelRect, resolutionPerCell).

using RTSTerrainStudio;
using UnityEngine;

public static class CliffExample
{
    /// <summary>Raises a square plateau by one cliff level around a world position.</summary>
    public static void RaisePlateau(RTSTerrain terrain, Vector3 worldCenter, int radiusInVertices)
    {
        MapData map = terrain.Map;
        if (map == null) return;

        // Nearest vertex to the centre (vertices sit on multiples of the cell size).
        Vector3 local = terrain.WorldToLocal(worldCenter);
        int cx = Mathf.RoundToInt(local.x / map.CellSize);
        int cz = Mathf.RoundToInt(local.z / map.CellSize);

        int x0 = Mathf.Max(0, cx - radiusInVertices), x1 = Mathf.Min(map.Width, cx + radiusInVertices);
        int z0 = Mathf.Max(0, cz - radiusInVertices), z1 = Mathf.Min(map.Height, cz + radiusInVertices);
        for (int z = z0; z <= z1; z++)
        {
            for (int x = x0; x <= x1; x++)
            {
                int i = map.VertexIndex(x, z);
                // Levels are bytes from 0 to 15: always clamp.
                map.CliffLevels[i] = (byte)Mathf.Min(map.CliffLevels[i] + 1, MapData.MaxCliffLevel);
            }
        }

        // Convert the changed vertices to the cells around them and notify the terrain.
        var vertexRect = new RectInt(x0, z0, x1 - x0 + 1, z1 - z0 + 1);
        RectInt cells = BrushUtility.VertexRectToCellRect(map, vertexRect);
        terrain.NotifyChanged(MapLayers.CliffLevels, cells);
    }
}

Coordenadas y varios terrenos

Todos los datos del mapa se guardan en el espacio local del mapa. El transform del GameObject de RTSTerrain sitúa ese espacio en el mundo.

Espacio local del mapa

• El origen es el vértice (0, 0), la esquina de la celda (0, 0). X y Z van de 0 a map.WorldSize en metros; Y apunta hacia arriba.
• El vértice (x, z) está en la posición local (x × CellSize, height, z × CellSize); el centro de la celda (x, z) está en ((x + 0.5) × CellSize, …, (z + 0.5) × CellSize).
• La Y local = 0 corresponde al nivel 0 con una altura fina de 0. Un mapa nuevo con nivel base 2 y niveles de 2 m tiene el suelo en la Y local = 4 m.
• Los GameObjects de los chunks cuelgan de un hijo oculto del terreno llamado RTS Chunks (RTSTerrain.ChunkRoot). Esa raíz no tiene desplazamiento ni rotación locales y compensa la escala del terreno, y cada chunk tiene un transform local de identidad, de modo que el espacio de objeto de los meshes de los chunks es el espacio local del mapa. Esto es importante cuando escribes shaders para el terreno.

Conversión entre el espacio del mundo y el del mapa

using RTSTerrainStudio;
using Unity.Mathematics;
using UnityEngine;

/// <summary>Add to any GameObject and use the context menu to see the map data under it.</summary>
public class TerrainProbe : MonoBehaviour
{
    [ContextMenu("Probe Terrain")]
    void Probe()
    {
        // Several terrains can exist: find the one below this object.
        RTSTerrain terrain = RTSTerrain.FindAt(transform.position);
        if (terrain == null || terrain.Map == null) { Debug.Log("Not above an RTS Terrain."); return; }
        MapData map = terrain.Map;

        // World -> map-local (origin at vertex 0,0; position and Y rotation only).
        Vector3 local = terrain.WorldToLocal(transform.position);
        int2 cell = terrain.WorldToCell(transform.position);

        // Nearest vertex.
        int vx = Mathf.Clamp(Mathf.RoundToInt(local.x / map.CellSize), 0, map.Width);
        int vz = Mathf.Clamp(Mathf.RoundToInt(local.z / map.CellSize), 0, map.Height);
        int v = map.VertexIndex(vx, vz);

        // Splat texel below the object (SplatResolution texels per cell side).
        int tx = Mathf.Clamp((int)(local.x / map.CellSize * map.SplatResolution), 0, map.SplatWidth - 1);
        int tz = Mathf.Clamp((int)(local.z / map.CellSize * map.SplatResolution), 0, map.SplatHeight - 1);
        int dominantLayer = map.GetDominantLayer(map.SplatIndex(tx, tz));

        Debug.Log($"Cell {cell}, vertex ({vx},{vz}): level {map.CliffLevels[v]}, fine height {map.Heights[v]:0.00} m, " +
                  $"vertex height {map.GetVertexHeight(vx, vz):0.00} m. Ground at world Y {terrain.GetHeight(transform.position):0.00}, " +
                  $"cliff level {terrain.GetCliffLevel(transform.position)}, dominant ground layer {dominantLayer}, " +
                  $"pathing {terrain.GetPathing(transform.position)}.");
    }
}

Reglas de posición, rotación y escala

Varios terrenos

Una escena puede contener cualquier número de componentes RTSTerrain. Cada uno tiene su propio mapa, tileset, bibliotecas, chunks y mapa de pathing.

• RTSTerrain.All enumera todos los terrenos activados; RTSTerrain.Main devuelve el primero (práctico para juegos de un solo mapa; los terrenos temporales de vista previa se omiten).
• RTSTerrain.FindAt(worldPosition) devuelve el terreno cuya área XZ contiene una posición.
• RTSTerrain.RaycastAll(ray, out hit) lanza un rayo contra todos los terrenos y devuelve el impacto más cercano (hit.terrain te indica cuál).
• RTSTerrain.TerrainEnabled / TerrainDisabled son eventos estáticos para los sistemas que hacen un seguimiento de los terrenos.
• Los terrenos son independientes: los mapas no se unen por sus bordes y la búsqueda de rutas (RTSPathfinder.FindPath(terrain, …)) funciona en un solo terreno a la vez. Para que dos mapas encajen sin costuras, da a sus vértices de borde las mismas alturas.

using RTSTerrainStudio;
using UnityEngine;

public static class TerrainLayout
{
    /// <summary>Places "east" directly next to "west" (along west's local +X), with the same rotation.</summary>
    public static void PlaceNextTo(RTSTerrain west, RTSTerrain east)
    {
        if (west.Map == null) return;
        float widthMetres = west.Map.WorldSize.x;   // map-local X extent in metres
        east.transform.SetPositionAndRotation(
            west.transform.position + west.transform.rotation * new Vector3(widthMetres, 0f, 0f),
            west.transform.rotation);
    }
}

Assets de mapa y archivos de mapa

Un mapa se guarda como un archivo .rtsmap. El mismo formato binario se usa en el Unity Editor (como asset de tu proyecto) y en el editor en el juego (como archivo en disco), así que los mapas creados por los jugadores se pueden abrir en Unity, y viceversa.

Archivos .rtsmap en el proyecto

Cuando Unity encuentra un archivo .rtsmap en la carpeta Assets, el importador RTSMapImporter lo convierte en un RTSMapAsset. El asset guarda los bytes comprimidos del archivo, una pequeña cabecera (nombre, autor, tamaño, jugadores, id del tileset) y una vista previa del minimapa que también se usa como miniatura en la ventana Project.

Crear un asset de mapa

• Tools ▸ RTS Terrain Studio ▸ New Map Wizard...: configuración guiada (datos básicos, tamaño, aspecto, terreno); escribe el archivo y crea un terreno para él, o lo asigna al terreno seleccionado.
• Assets ▸ Create ▸ RTS Terrain Studio ▸ Map (.rtsmap): crea en la carpeta seleccionada un mapa plano de 128 × 128 con la configuración predeterminada.
• Save As… en la ventana RTS Terrain Studio: escribe el mapa actual de un terreno en un archivo nuevo.
• Copia en la carpeta Assets un archivo .rtsmap creado con el editor en el juego; se importa como cualquier otro archivo.

El Inspector del asset de mapa

Selecciona un asset de mapa para ver su vista previa, nombre, autor, descripción, tamaño, jugadores, tileset y versión de formato, además de estadísticas (celdas, tamaño en el mundo, tamaño de celda, altura de nivel, posiciones iniciales, árboles, decoración, regiones, marcadores, capas de detalle, tamaño del archivo, memoria, última modificación).

La vista previa se vuelve a precalcular automáticamente cuando el tileset con el id del mapa se añade, se elimina o cambia sus colores del minimapa. Regenerar los arrays de texturas no vuelve a importar los mapas. Un archivo dañado se importa como un asset vacío con un icono de error y un error de importación en la consola.

Edición, Save y Save As

Asigna un asset de mapa al campo Map Asset de un RTSTerrain. Cuando el terreno se activa, carga el mapa en memoria, y todas las ediciones se realizan sobre esa copia en memoria. El archivo de la escena solo guarda la referencia al asset, nunca los datos del mapa en sí.

• Save (en la cabecera de la ventana RTS Terrain Studio, o Save Map en el menú de opciones del panel superpuesto RTS Terrain Studio de la Scene View) vuelve a escribir el mapa en su archivo .rtsmap y lo reimporta. Save aparece resaltado mientras haya cambios sin guardar.
• Save As… escribe un archivo nuevo y lo asigna al terreno sin volver a cargar el mapa, así que se conserva tu historial de deshacer.
• Open… carga otro asset de mapa; Reload vuelve a cargar el mapa desde su asset y descarta los cambios sin guardar.
• Un terreno sin asset de mapa crea un mapa a partir de sus Default Map Settings. Ese mapa solo existe en memoria hasta que uses Save As.
• Al guardar la escena (Ctrl+S) también se guardan los mapas editados de los terrenos de esa escena, y se ofrece Save As para los mapas nuevos que aún no tienen archivo. Ambos comportamientos se pueden desactivar en el menú de opciones del panel superpuesto de la Scene View (Save Maps When Saving the Scene, Offer Save As for New Maps).
• Si hay ediciones de mapa sin guardar, se te pregunta si quieres guardarlas antes de entrar en el modo Play, cerrar una escena o salir de Unity. Las ediciones hechas en el modo Play (con las herramientas de la Scene View o con el editor en el juego) también se ofrecen para guardar al salir del modo Play.

Archivos de mapa en tiempo de ejecución

En un juego compilado, los mapas son archivos normales en disco:

• RTSMapSerializer.DefaultMapsFolder es la carpeta Maps dentro de RTSMapSerializer.StorageRoot, que es Application.persistentDataPath, así que en Windows la carpeta suele ser %USERPROFILE%\AppData\LocalLow\<Company>\<Product>\Maps. En las builds para Web, StorageRoot es una carpeta del almacenamiento del navegador (consulta Mapas en el navegador).
• El editor en el juego (RTSRuntimeEditor) guarda y abre los mapas en su Maps Folder (vacío = la carpeta predeterminada indicada arriba; las rutas relativas se interpretan respecto a RTSMapSerializer.StorageRoot). Con Write Preview Images activado, escribe una pequeña imagen del minimapa, Name.preview.png, junto a cada mapa guardado para su explorador de mapas.
• Para compartir un mapa, copia el archivo .rtsmap en la carpeta de mapas de otro jugador o en un proyecto de Unity. En un navegador web, usa en su lugar los comandos Download Map e Import Map del editor en el juego.
• Los mapas que publiques con el juego pueden ser simplemente assets de mapa referenciados por un terreno o un script; se incluyen en la build como cualquier otro asset.

using System.IO;
using RTSTerrainStudio;
using UnityEngine;

public class SimpleMapList : MonoBehaviour
{
    [SerializeField] RTSTerrain terrain;

    /// <summary>Logs all maps in the default folder without loading them, then opens the first one.</summary>
    [ContextMenu("List And Open Maps")]
    void ListAndOpen()
    {
        string folder = RTSMapSerializer.DefaultMapsFolder;
        if (!Directory.Exists(folder)) { Debug.Log("No maps folder yet: " + folder); return; }

        string[] files = Directory.GetFiles(folder, "*" + RTSMapSerializer.FileExtension);
        foreach (string path in files)
        {
            // The header is stored uncompressed, so this is fast even for big maps.
            if (RTSMapSerializer.TryReadHeaderFromFile(path, out RTSMapHeader h))
                Debug.Log($"{h.name} by {h.author}: {h.width} x {h.height} cells, {h.maxPlayers} players, saved {h.Modified}");
        }

        if (files.Length > 0 && terrain != null)
        {
            try
            {
                terrain.LoadFromFile(files[0]);   // the terrain owns and disposes the loaded map
            }
            catch (InvalidDataException e)
            {
                Debug.LogError("The map file is damaged: " + e.Message);
            }
        }
    }
}

Tilesets

Un tileset (RTSTileset) define el aspecto de un mapa: hasta 16 capas de suelo, hasta 4 capas de acantilado y el estilo del agua, de forma comparable a los tilesets de verano, invierno o desierto de los editores de mapas de los RTS clásicos. Puedes tener tantos tilesets como quieras y cambiar el tileset de un terreno en cualquier momento: los mapas pintados solo guardan índices de capa, así que el mismo mapa se puede mostrar en verano y en invierno.

1. Crea un tileset con Assets ▸ Create ▸ RTS Terrain Studio ▸ Tileset.
2. Arrastra tus texturas de suelo a la sección Ground Layers del Inspector. Se crea una capa por cada textura de albedo. Los mapas de normales y de relieve correspondientes se detectan por el sufijo del nombre de archivo (por ejemplo, _n, _normal, _nrm, _normalgl, _h, _height, _disp); los mapas de rugosidad, AO y metálico se ignoran, así que puedes soltar una carpeta entera de texturas descargada.
3. Añade las capas de acantilado en Cliff Layers de la misma manera.
4. Asigna el tileset al campo Tileset de tu RTSTerrain.
5. Haz clic una vez en Build Texture Arrays, en la sección Texture Arrays (consulta Arrays de texturas).

Campos del tileset

Campos de las capas de suelo

Campos de las capas de acantilado

Las paredes de acantilado se texturizan con proyección triplanar en el espacio local del mapa, por lo que las texturas de acantilado no necesitan una distribución especial de UV.

Perfil de agua

El perfil de agua forma parte del tileset y lo usan el renderizador de agua, el mapa de pathing y el minimapa.

Editar tilesets desde código

Los tilesets son ScriptableObjects. Después de cambiar campos desde código, llama a tileset.NotifyChanged() para que los terrenos actualicen sus materiales. tileset.GetGroundLayer(index) y GetCliffLayer(index) devuelven null para las ranuras sin usar.

Arrays de texturas

El shader del terreno dibuja las 20 capas en una sola pasada, por lo que todas las texturas de las capas se empaquetan en dos arrays de texturas de GPU. Nunca tienes que crear estos arrays tú mismo: entran texturas normales de Unity de cualquier tamaño y formato, y salen los arrays.

Estructura

• El primer slice de acantilado es RTSTileset.CliffSliceOffset (16); el total es RTSTileset.TotalSlices (20).
• La altura (alfa) proviene del Height Map de la capa (canal R); si no hay ninguno, del alfa del albedo cuando Height From Albedo Alpha está activado; en caso contrario, se usa una constante de 0.5.
• Las normales se desempaquetan durante la generación, así que tus mapas de normales pueden usar la importación de mapas de normales de Unity (DXT5nm / BC5) como siempre. Las capas sin mapa de normales reciben una normal plana.
• Las capas sin albedo reciben un slice gris neutro con un patrón sutil; el shader sigue aplicando el tinte.
• Cada slice tiene una cadena de mipmaps completa y usa filtrado trilineal. Las texturas de origen de cualquier tamaño se redimensionan a la Resolution elegida.

Arrays generados y alternativa en tiempo de ejecución

Los arrays pueden crearse de dos maneras:

La sección Texture Arrays muestra una insignia de estado:

• Not built: el terreno usa arrays generados en tiempo de ejecución. Haz clic una vez en Build Texture Arrays.
• Up to date: se muestran el formato, el tamaño, el número de mipmaps y la memoria.
• Outdated: han cambiado las texturas, la resolución o la compresión, o los arrays se generaron para otra plataforma o compresión de texturas. Vuelve a generarlos o deja que lo haga la próxima build del juego.
• Building: hay una generación en curso o programada.

La sección también muestra el formato de destino para la plataforma de compilación activa, el tamaño y el tiempo de generación estimados, y pide confirmación antes de generar arrays de más de 256 MB. Clear elimina los arrays generados.

Builds del juego

Las builds del juego usan los arrays generados tal como están, porque solo el editor puede compararlos con las texturas de origen. Por eso, los arrays desactualizados se regeneran automáticamente justo antes de cada build del juego, y los tilesets cuyos arrays nunca se generaron siguen usando arrays generados en tiempo de ejecución. Los detalles, incluidos el modo batch y -rtsAllowOutdatedTextureArrays, están en Arrays de texturas en las builds del juego. Además, las builds del juego liberan la copia en la CPU de los arrays generados la primera vez que los usan, lo que ahorra aproximadamente tanta memoria como la que ocupan los arrays en la GPU.

Desde código: tileset.HasValidBuiltArrays indica si se usarán los arrays comprimidos. En el editor, deben existir y coincidir con ComputeContentHash(). Una build del juego confía en los arrays generados hasta que tu código cambie en tiempo de ejecución las texturas de las capas, la resolución o la compresión; a partir de ese momento, pasa a usar arrays generados en tiempo de ejecución. Los valores de ComputeContentHash() solo son comparables dentro del editor o dentro de una misma sesión del juego, porque el editor calcula el hash a partir del estado de importación de las texturas. Si HasValidBuiltArrays es false, RTSTerrain genera arrays sin comprimir en tiempo de ejecución (RTSTextureArrayBuilder.Acquire). tileset.BuiltAlbedoArray / BuiltNormalArray dan acceso a los arrays generados. En tu propio código de tiempo de ejecución, usa RTSShaderReferences.FindShader(name) (y FindMaterial(name)) en lugar de Shader.Find, para que la búsqueda también funcione en las builds del juego.

Auto Build

Con Auto Build activado (la opción predeterminada; es una preferencia del editor que se aplica a todos los tilesets), los arrays que ya se habían generado se regeneran con compresión rápida un segundo después de que cambien las texturas, la resolución o la compresión. La primera generación siempre se inicia a mano. Una generación automática cancelada o fallida no se reintenta hasta que cambie el contenido o el formato de destino. En cambio, al hacer clic en el botón Build Texture Arrays se usa la calidad de compresión normal, que se ve algo mejor, así que hazlo antes de publicar el juego.

Biblioteca de vegetación

Una biblioteca de vegetación (RTSVegetationLibrary) enumera la hierba, las plantas y los árboles disponibles para pintar. Crea una con Assets ▸ Create ▸ RTS Terrain Studio ▸ Vegetation Library y asígnala al campo Vegetation Library del RTSTerrain. Para mostrar la vegetación, el terreno también necesita un componente RTSVegetationRenderer (el Inspector de RTSTerrain ofrece añadirlo).

El Inspector tiene dos pestañas, Details y Trees, con una cuadrícula de miniaturas. Suelta en ella prefabs (árboles), texturas (planos de hierba) o meshes (meshes de detalle) para añadir entradas. Cada entrada recibe un id estable que usan los mapas; las entradas duplicadas reciben automáticamente ids nuevos.

Prototipos de detalle

Los detalles son plantas pequeñas y numerosas que se pintan por densidad (consulta Densidad de detalles). Se generan en parches de 16 × 16 celdas y se dibujan con el shader procedural interno Hidden/RTS Terrain Studio/Detail, que se encarga del viento, la niebla de guerra y la variación de color.

Prototipos de árbol

Los árboles son instancias individuales (consulta Instancias de árboles y de decoración) que se colocan con Place Trees.

Instanciación por GPU

Los árboles en modo Instanced se dibujan con instanciación por GPU, por lo que sus materiales deberían tener activada la opción Enable GPU Instancing. Si un material la tiene desactivada, el renderizador usa automáticamente una copia oculta del material con instanciación (que se mantiene sincronizada con el original mientras editas), y el Inspector de la biblioteca muestra un mensaje informativo con un botón Enable que corrige el propio material. Los detalles no necesitan instanciación en sus materiales, porque siempre se dibujan con el shader procedural de detalles.

Desde código, las instancias de árbol se eliminan con RTSVegetationRenderer.RemoveTree(id) (por ejemplo, cuando un trabajador tala un árbol), se buscan con TryFindNearestTree, y GetTreeObject(id) devuelve su GameObject o su proxy de collider.

Editar bibliotecas desde código

Los mapas guardan una paleta de ids de prototipo, así que debes resolver cada índice de la paleta a través de la biblioteca:

• Árboles: vegetationLibrary.FindTree(map.TreePrototypeIds[tree.prototype]).
• Capas de detalle: vegetationLibrary.FindDetail(layer.prototypeId).
• Decoración: decorLibrary.Find(map.DecorPrototypeIds[d.prototype]). Obtén el prefab de la variante con prototype.GetPrefab(d.variant): 0 es el prefab principal, y las variantes no válidas o vacías recurren a él. VariantCount incluye el prefab principal.
• decorLibrary.GetCategories() enumera las categorías en el orden en que se muestran (los prototipos sin categoría aparecen como Misc).
• vegetationLibrary.EnsureUniqueIds() asigna ids nuevos a las entradas duplicadas.

Después de cambiar una biblioteca desde código, llama a library.NotifyChanged() (lanza el evento Changed de la biblioteca), para que RTSTerrain lance LibrariesChanged y los renderizadores se actualicen. Es la misma regla que para los tilesets.

Biblioteca de decoración

Una biblioteca de decoración (RTSDecorLibrary) enumera los props (doodads) que puedes colocar: rocas, ruinas, vallas, cajas, edificios o cualquier otro prefab. Crea una con Assets ▸ Create ▸ RTS Terrain Studio ▸ Decor Library y asígnala al campo Decor Library del RTSTerrain. Un componente RTSDecorManager en el terreno mantiene la escena sincronizada con las instancias colocadas.

El Inspector muestra los prototipos en una cuadrícula con miniaturas generadas automáticamente y una pestaña por categoría (además de All). Suelta prefabs sobre ella para añadirlos a la categoría actual; haz clic con el botón derecho en la pestaña de una categoría para cambiarle el nombre. Los prototipos sin categoría aparecen en Misc.

Campos de los prototipos de decoración

Huellas

• Una huella circular usa la X de Footprint Size como radio, multiplicada por la mayor escala horizontal de la instancia.
• Una huella rectangular sigue la rotación de la instancia (sus ejes X y Z proyectados sobre el suelo) y su escala en X/Z, de modo que un muro girado obstruye exactamente su propia superficie.
• No se escribe ninguna huella si la forma es None, si el efecto es None o si la instancia tiene el indicador DecorFlags.IgnorePathing.
• Usa solo Unbuildable para decoraciones planas por encima de las que pueden caminar las unidades (flores, escombros) y Unwalkable para objetos sólidos.

Modos de generación

En cuanto a la instanciación por GPU, la decoración instanciada se comporta igual que los árboles instanciados: los materiales sin Enable GPU Instancing se dibujan mediante una copia oculta con la instanciación activada. Los objetos generados se reutilizan desde un pool; RTSDecorManager.GetInstanceObject(id) devuelve el objeto generado de una instancia, y RTSDecorInstance.FromCollider(collider) devuelve la instancia a la que pertenece un impacto de física.

El formato de archivo .rtsmap

Esta sección está dirigida a programadores que quieran leer mapas con otras herramientas, escribir conversores o añadir sus propios datos. No la necesitas para usar el paquete: RTSMapSerializer se encarga de todo.

Estructura binaria

Todos los números están en little-endian. Las cadenas usan el formato de BinaryWriter de .NET: una longitud con codificación de 7 bits seguida de los bytes en UTF-8.

La cabecera no está comprimida para que los exploradores de mapas puedan mostrar el nombre, el autor, el tamaño y los jugadores sin descomprimir el mapa (RTSMapSerializer.TryReadHeader, TryReadHeaderFromFile, struct RTSMapHeader). Los lectores saltan al final de la cabecera gracias a su longitud, así que las versiones futuras pueden añadirle campos nuevos al final.

Secciones

Cada sección es [int32 tag][int32 length][payload]. Las etiquetas son códigos FourCC guardados en little-endian, de modo que el primer carácter está en el byte menos significativo (DIMS = 0x534D4944). Los arrays de datos ráster se escriben como un int32 con el número de elementos seguido de los elementos sin procesar.

Las «propiedades» se escriben como un int32 con la cantidad seguido de pares de cadenas clave/valor. El mapa de pathing derivado no se guarda; solo se guardan los ajustes manuales de pathing.

Secciones desconocidas, archivos dañados y versionado

• Las secciones desconocidas se omiten gracias a su longitud. Por eso, las versiones anteriores del paquete pueden leer archivos más recientes con secciones adicionales, y tus secciones personalizadas nunca hacen fallar a otros lectores.
• Si un archivo tiene una versión de formato más reciente que la del lector, se registra una advertencia y se lee igualmente; los datos desconocidos se omiten.
• Si el número de elementos de una capa ráster no coincide con el tamaño del mapa, se registra una advertencia; se lee lo que cabe y se omite el resto.
• Los archivos truncados o dañados lanzan un único tipo de excepción, System.IO.InvalidDataException. Si el número mágico de un archivo es incorrecto, se informa con el mensaje «Not an RTS Terrain Studio map file».
• RTSMapSerializer.SaveToFile escribe primero en <path>.tmp y después reemplaza el archivo, de modo que un cierre inesperado durante el guardado nunca deja un mapa a medio escribir.
• Regla de compatibilidad del formato: los datos nuevos se añaden como secciones nuevas o como campos añadidos al final de la cabecera, nunca modificando las secciones existentes. Haz lo mismo con tus propias secciones y guarda un número de versión dentro de tu carga útil.

Secciones personalizadas

Puedes guardar tus propios datos en los archivos de mapa, por ejemplo, reglas de juego, disparadores o datos de misiones. Dos hooks estáticos de RTSMapSerializer lo hacen posible:

• Elige etiquetas que no coincidan con las integradas; haz que empiecen por X (por ejemplo, XGLD). Nunca uses 0, que marca el final de las secciones.
• Ambos hooks son delegados normales: combina manejadores con += y quítalos con -=, de modo que varios sistemas puedan añadir secciones.
• Comprueba la etiqueta en tu lector e ignora las secciones que no sean tuyas.
• MapData no tiene un espacio para tus datos. Guárdalos junto al mapa (el ejemplo usa una ConditionalWeakTable). Ni MapData.Clone() ni ResizeMap copian los datos guardados de esta forma, y tampoco se registran en el historial de deshacer.
• Registra los hooks antes de cargar o guardar cualquier mapa. En el Unity Editor, el importador también lee los mapas y el comando Save los escribe, así que regístralos también para el editor (el ejemplo usa InitializeOnLoadMethod).

using System;
using System.IO;
using System.Runtime.CompilerServices;
using RTSTerrainStudio;
using UnityEngine;

/// <summary>Stores a "starting gold" value in every map file, in a custom section "XGLD".</summary>
public static class StartingGoldSection
{
    // FourCC, little-endian like the built-in tags: the first character is in the lowest byte.
    const int Tag = 'X' | ('G' << 8) | ('L' << 16) | ('D' << 24);
    const int PayloadVersion = 1;

    /// <summary>Our data for one map.</summary>
    public sealed class Data
    {
        public int startingGold = 500;
    }

    // One Data object per MapData. Entries disappear automatically together with their map.
    static readonly ConditionalWeakTable<MapData, Data> s_Data = new ConditionalWeakTable<MapData, Data>();

    /// <summary>Returns the data of a map (created with defaults when the map has none).</summary>
    public static Data Get(MapData map) => s_Data.GetOrCreateValue(map);

#if UNITY_EDITOR
    [UnityEditor.InitializeOnLoadMethod]          // editor: importer and Save
#endif
    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]   // player and Play Mode
    static void Register()
    {
        // Remove first so a second registration does not add the handlers twice.
        RTSMapSerializer.CustomSectionWriter -= Write;
        RTSMapSerializer.CustomSectionWriter += Write;
        RTSMapSerializer.CustomSectionReader -= Read;
        RTSMapSerializer.CustomSectionReader += Read;
    }

    static void Write(MapData map, Action<int, byte[]> writeSection)
    {
        if (!s_Data.TryGetValue(map, out Data data)) return;   // nothing to save for this map
        using (var stream = new MemoryStream())
        {
            using (var writer = new BinaryWriter(stream))
            {
                writer.Write(PayloadVersion);   // our own version, so the payload can grow later
                writer.Write(data.startingGold);
            }
            writeSection(Tag, stream.ToArray());
        }
    }

    static void Read(MapData map, int tag, byte[] payload)
    {
        if (tag != Tag) return;   // another system's section: ignore it
        using (var reader = new BinaryReader(new MemoryStream(payload)))
        {
            int version = reader.ReadInt32();
            if (version >= 1) Get(map).startingGold = reader.ReadInt32();
        }
    }
}

Úsalo en el código del juego con StartingGoldSection.Get(terrain.Map).startingGold. Después de cambiar el valor en el editor, marca el mapa como modificado (por ejemplo, terrain.NotifyChanged(MapLayers.Info, terrain.Map.CellBounds), o establece terrain.HasUnsavedChanges = true) para que se guarde.

La ventana de RTS Terrain Studio

La ventana es el centro de control del editor. No guarda ningún estado de edición propio: muestra y modifica la sesión de edición compartida que también usan la Scene View, el panel superpuesto (overlay) de la Scene View y el Inspector de RTS Terrain. Todo lo que cambies en un sitio aparece de inmediato en los demás.

Puedes abrirla de cualquiera de estas formas:

• Tools ▸ RTS Terrain Studio ▸ Editor Window
• el botón Open RTS Terrain Studio del Inspector de RTS Terrain
• el botón de la ventana en el panel superpuesto RTS Terrain Studio de la Scene View

La ventana tiene cuatro áreas: la cabecera arriba, la barra de pestañas, la página desplazable y la barra de estado abajo.

Páginas de herramientas

Cada pestaña de categoría muestra una pila de tarjetas. Puedes contraer cualquier tarjeta haciendo clic en su cabecera.

Tarjeta	Contenido
Categoría Tools	La cuadrícula de herramientas. Haz clic en una herramienta para pintar con ella en la Scene View. Vuelve a hacer clic en la herramienta activa para dejar de editar. Pasa el ratón sobre una herramienta para leer su descripción y sus teclas modificadoras. Las herramientas personalizadas que escribas aparecen aquí automáticamente.
Tarjeta de herramienta	El nombre, la descripción y la sugerencia de la herramienta seleccionada, un botón ? que abre la sección correspondiente de este manual y una línea de estado en directo. Mueve el ratón sobre el terreno para verla, por ejemplo, Ground 4.25 m | Fine +0.25 m | Level 2 para las herramientas de altura o Level 2 → 3 para las herramientas de acantilado.
Getting Started	Se muestra cuando no hay ninguna herramienta de esta categoría seleccionada. Si estás pintando con una herramienta de otra categoría, indica Active tool: X y ofrece Go to Tool.
Brush	Forma, radio, intensidad, dureza, curva de atenuación, rotación, rotación aleatoria, espaciado y variación aleatoria. Todas las herramientas de pincel comparten estos ajustes. Se oculta en las herramientas que no usan el pincel. Consulta Pinceles.
Symmetry	Modo y centro de simetría (no se muestra en las herramientas de arrastre). Consulta Simetría.
Herramienta Settings	Los ajustes de la herramienta seleccionada, generados automáticamente a partir del código de la herramienta. Se recuerdan entre sesiones del editor. Las tablas de la referencia de herramientas enumeran todos los ajustes.
Acciones de categoría	Tarjetas adicionales para algunas categorías: Auto Paint Whole Map (Paint), Selection (Decor, mientras Select Decor está activa), Water at Cursor (Water) y Pathing Overlay (Pathing).

Mientras la edición está en pausa, un aviso indica Editing is paused – the Scene View uses Unity's tools. Su botón Resume vuelve a activar la edición.

Pestaña Map

La pestaña Map contiene los ajustes y las operaciones que afectan a todo el mapa. Todos los cambios se pueden deshacer, salvo que su cuadro de diálogo indique lo contrario. El botón ? de la parte superior abre esta sección.

Pestaña Settings

Pintar en la Scene View

Toda la edición se hace en la Scene View. Cuando la edición del terreno está activada y hay una herramienta seleccionada, el botón izquierdo del ratón pinta con la herramienta en lugar de seleccionar objetos. Activa la edición con el botón Editing de la ventana, el botón Start Editing del panel superpuesto, el botón Edit Terrain del inspector o haciendo clic en una herramienta. Desactívala con Esc.

using RTSTerrainStudio.Editor;
using UnityEditor;

static class MyBuildSteps
{
    [MenuItem("Tools/My Project/Run Map Batch")]
    static void RunMapBatch()
    {
        // No save prompts while this scope is open. Scopes can be nested.
        using (RTSMapSaveGuard.Suppress())
        {
            // ... open scenes, edit or generate maps, enter and leave Play Mode ...
        }
    }
}

Atajos de teclado

Los atajos de la Scene View están registrados en el Shortcut Manager de Unity, en la categoría RTS Terrain Studio. Solo están activos mientras la edición del terreno está activada, una Scene View o una de las ventanas del editor de RTS Terrain Studio tiene el foco del teclado (o el ratón está sobre una Scene View) y no estás escribiendo en un campo de texto o numérico. Fuera de la edición, teclas como R o las teclas numéricas conservan su función normal en Unity.

El propio paquete gestiona estas teclas y acciones del ratón, que no se pueden reasignar:

Las siguientes teclas son atajos y comandos propios de Unity. RTS Terrain Studio reacciona a ellas, pero siguen las asignaciones que tengas en Edit ▸ Shortcuts..., dentro de las categorías de Unity (Main Menu/Edit, Tools):

R con Select Decor es la entrada propia del paquete RTS Terrain Studio/Toggle Random Rotation: mientras Select Decor está activa, cambia a la herramienta Scale de Unity en lugar de activar o desactivar la rotación aleatoria.

Pinceles

Todas las herramientas de pincel comparten un mismo pincel. Lo configuras en la tarjeta Brush de cualquier página de herramienta, en el panel superpuesto (Size y Strength) o con los atajos. El pincel se recuerda entre sesiones del editor.

Simetría

La simetría repite cada toque, clic y objeto colocado en posiciones reflejadas o rotadas. Así es como se crean mapas competitivos justos: cada jugador recibe las mismas colinas, acantilados, rampas, árboles y minas de oro. Elige el modo en la tarjeta Symmetry o en el panel superpuesto. Las guías magenta de la Scene View muestran los ejes y el centro.

Centre es el centro de simetría en coordenadas normalizadas del mapa: (0.5, 0.5) es el centro del mapa y el valor predeterminado. Reset lo devuelve a esa posición. Si mueves el centro, algunas copias pueden quedar fuera del mapa y se omiten; la tarjeta muestra una advertencia.

Deshacer y rehacer

Cada edición del terreno se registra en el propio historial de deshacer del mapa, que está vinculado al sistema de deshacer de Unity. Ctrl+Z, Ctrl+Y y el menú Edit ▸ Undo funcionan con las ediciones del terreno exactamente igual que con cualquier otro cambio, y el menú Edit muestra el nombre del paso, por ejemplo, Undo Raise / Lower. Los botones Undo y Redo de la cabecera de la ventana hacen lo mismo y mantienen sincronizado el historial de Unity. Deshacer entretanto un cambio en otro objeto no altera el historial del terreno.

using RTSTerrainStudio;
using RTSTerrainStudio.Editor;
using UnityEditor;

static class MyTerrainCommands
{
    [MenuItem("Tools/My Project/Raise Whole Map 1 m")]
    static void RaiseWholeMap()
    {
        // The terrain edited by the RTS Terrain Studio window and the Scene View tools.
        RTSTerrain terrain = RTSEditorContext.Terrain;
        if (terrain == null || terrain.Map == null) return;

        RTSEditSession session = RTSEditorContext.Session;

        // Records the Heights layer, runs the code and pushes one undo step named "Raise Whole Map".
        session.RunOperation("Raise Whole Map", MapLayers.Heights, ctx =>
        {
            var heights = ctx.Map.Heights; // fine height per vertex, on top of the cliff level
            for (int i = 0; i < heights.Length; i++)
                heights[i] = TerrainToolUtility.ClampFineHeight(ctx.Map, heights[i] + 1f);

            // Tell the terrain which layers changed so meshes, water and pathing are rebuilt.
            ctx.Terrain.NotifyChangedAll(MapLayers.Heights);
        });
    }
}

Referencia de herramientas

Las siguientes secciones describen todas las herramientas de las ocho categorías. Todas funcionan igual en el Unity Editor y en el editor en el juego. Algunas convenciones se aplican a todas ellas:

• Id es el identificador único de la herramienta. Úsalo en código, por ejemplo, RTSEditorContext.ActivateTool("height.raise").
• Entrada: las herramientas de pincel pintan mientras arrastras. Las herramientas de clic actúan una vez por clic. Las herramientas de arrastre funcionan presionando, arrastrando y soltando (rectángulos, selección por rectángulo).
• Repeticiones: toques por segundo mientras mantienes presionado el botón sin mover el ratón.
• Shift invierte el efecto y Ctrl+clic toma un valor del terreno, donde la tabla lo indica.
• Cada ajuste aparece con su rango y su valor predeterminado. Los ajustes se conservan entre sesiones del editor. Reset All Tool Settings, en la pestaña Settings, restablece los valores predeterminados.

using RTSTerrainStudio;

// Appears on the Height tab after the built-in tools (Order 100).
public sealed class StepTool : HeightTool
{
    public override string Id => "mygame.step";
    public override string DisplayName => "Step";
    public override string Description => "Raises the ground under the brush by a fixed step per click.";
    public override string Hint => "Shift: step down";
    public override int Order => 100;

    // One dab per click; keep the brush panel visible for the radius and falloff.
    public override ToolInputMode InputMode => ToolInputMode.Click;
    public override bool UsesBrush => true;

    [ToolSetting("Step", Min = 0.05f, Max = 4f, Order = 0, Tooltip = "Height change per click in metres at full strength.")]
    public float step = 0.5f;

    // Called once per click and once for every symmetry copy.
    public override void ApplyDab(RTSToolContext ctx, in BrushDab dab)
    {
        var map = ctx.Map;
        // Computes the vertex weights and records the Heights layer for undo.
        bool any = BeginVertexEdit(ctx, dab, out var w, out var cells);
        using (w) // the weights must always be disposed
        {
            if (!any) return;
            float sign = dab.invert ? -1f : 1f; // Shift inverts
            var heights = map.Heights;
            for (int z = w.rect.yMin; z < w.rect.yMax; z++)
            for (int x = w.rect.xMin; x < w.rect.xMax; x++)
            {
                float weight = w[x, z];
                if (weight <= 0f) continue;
                int i = map.VertexIndex(x, z);
                heights[i] = TerrainToolUtility.ClampFineHeight(map, heights[i] + sign * step * dab.strength * weight);
            }
        }
        // Rebuilds the chunks, water and pathing of the changed cells.
        EndVertexEdit(ctx, cells);
    }
}

Herramientas de altura

Las herramientas de altura esculpen la altura fina: colinas, valles, caminos y detalles naturales sobre los niveles de acantilado. Nunca cambian los niveles de acantilado, así que las paredes de acantilado se mantienen nítidas. La línea de estado muestra la altura del suelo, la altura fina y el nivel de acantilado bajo el cursor.

Ajustes de Raise / Lower

Ajustes de Smooth

Ajustes de Flatten

Ajustes de Set Height

Ajustes de Noise

Ajustes de Terrace

Ajustes de Erode

Herramientas de acantilado

Las herramientas de acantilado cambian el nivel de acantilado de los vértices (0–15) y el aspecto de las paredes de acantilado entre niveles. El pincel se ajusta a los vértices y actúa como una selección de bordes duros, así que pintas vértices completos, nunca medios niveles. La línea de estado muestra el nivel que hay bajo el cursor y el nivel que vas a pintar, por ejemplo, Level 2 → 3.

Ajustes de Raise / Lower Level

El nivel objetivo se toma del vértice que hay bajo el cursor al comenzar el trazo: un nivel más alto (o más bajo con Shift). Al arrastrar se pinta ese mismo nivel, así que puedes ampliar una meseta sin apilar niveles. La herramienta solo sube (o solo baja) vértices.

Ajustes de Set Level

Ramp

La herramienta Ramp no tiene ajustes. Una celda se convierte en rampa cuando sus cuatro vértices de esquina están marcados como rampa y la celda abarca una diferencia de exactamente un nivel. La línea de estado te ayuda: cuenta las celdas de rampa válidas bajo el pincel, menciona las celdas marcadas que no tienen diferencia de nivel y avisa cuando una rampa abarca más de un nivel (quedaría estirada).

Ajustes de Cliff Type

Ajustes de Clean Cliffs

Bordes de acantilado automáticos

En los editores de mapas de los RTS clásicos, subir un acantilado también cambia el suelo que lo rodea. Las herramientas de acantilado hacen lo mismo: cuando termina un trazo, el suelo a lo largo de cada nuevo borde de acantilado se pinta con la capa de suelo indicada en el ajuste Edge Ground Layer del tipo de acantilado, por ejemplo, un reborde pedregoso de «Rocky Dirt». El reborde sigue el contorno redondeado del acantilado, se desvanece a lo largo del ancho definido en Edge Width y tiene un contorno ligeramente irregular, de modo que se ve natural y no cuadriculado.

1. Selecciona el tileset y abre Cliff Layers. En cada tarjeta de acantilado, elige una capa en el ajuste Edge Layer (los tilesets de demostración usan Rocky Dirt).
2. Elige Raise / Lower Level, Set Level, Ramp o Clean Cliffs y deja activado Paint Cliff Edges.
3. Pinta los acantilados como de costumbre. El reborde aparece al soltar el botón del ratón.

• Un solo paso de deshacer: el cambio de nivel y la pintura del borde se deshacen juntos.
• Simetría: todas las copias simétricas reciben sus bordes en la misma pasada.
• Rampas: las celdas de rampa nunca reciben reborde. Pintar una rampa a través de un borde elimina allí el reborde cuando Clean Up Old Edges está activado.
• Acantilados desplazados: con Clean Up Old Edges activado, el reborde de un borde que ha desaparecido (una meseta bajada, una meseta ampliada) se vuelve a eliminar. Esto también elimina la capa de borde si la pintaste allí a mano.
• Opcional: desactiva Paint Cliff Edges para una herramienta o establece el ajuste Edge Layer del tipo de acantilado en None para todo el tileset. Si la opción está activada pero no hay ninguna capa de borde asignada, la línea de estado lo indica.

Herramientas de pintura

Las herramientas de pintura pintan las capas de suelo del tileset (hasta 16). Cada texel del splat map guarda los pesos de todas las capas, que siempre suman el 100 %. Si la capa seleccionada no existe en el tileset o no tiene textura, la línea de estado lo indica en lugar de pintar en silencio con una capa alternativa.

Ajustes de Paint Layer

Ajustes de Tile Paint

Ajustes de Fill / Replace

Cada clic es un paso de deshacer que solo registra la zona que realmente ha cambiado.

Ajustes de Smooth Paint

Ajustes de Auto Paint

La pestaña Paint también muestra la tarjeta Auto Paint Whole Map, que vuelve a pintar todo el mapa a partir del perfil en un solo paso.

Herramientas de vegetación

Las herramientas de vegetación pintan hierba y plantas pequeñas (detalles) y colocan árboles a partir de la Vegetation Library del terreno. Si el terreno no tiene ninguna, la página de la herramienta ofrece el botón Create Vegetation Library. Elige prototipos en la cuadrícula; si no hay ninguno seleccionado, se usa el primer prototipo de la biblioteca.

Ajustes de Paint Details

Ajustes de Erase Details

Ajustes de Place Trees

Ajustes de Erase Trees

Herramientas de decoración

Las herramientas de decoración colocan, borran y editan props como rocas, ruinas y vallas de la Decor Library del terreno. Si el terreno no tiene ninguna, la página de la herramienta ofrece el botón Create Decor Library. La cuadrícula de prototipos tiene un campo de búsqueda y filtros por categoría.

Ajustes de Place Decor

Ajustes de Erase Decor

Ajustes de Select Decor

Tarjeta Selection

Mientras Select Decor está activa, la pestaña Decor muestra la tarjeta Selection con el número de objetos seleccionados. Cada botón de edición (Delete, Duplicate, Snap to Ground, Rotate 90°, Lock, Unlock) cuenta como un solo paso de deshacer. Select All y Clear solo cambian la selección.

El uso de manipuladores para mover, rotar y escalar se describe en Manipuladores de la selección de decoración.

Herramientas de agua

El agua se guarda por vértice: un vértice está mojado, con una altura de la superficie del agua, o seco. Las herramientas de agua usan una selección estricta, como las herramientas de acantilado. La tarjeta Water at Cursor muestra el nivel y la profundidad del agua bajo el ratón y si cuenta como agua poco profunda (transitable) o profunda, según el límite de agua poco profunda del tileset.

Ajustes de altura del agua (Paint Water y Flood Fill)

Ajustes de Paint Water

Ajustes de Flood Fill

Herramientas de pathing

El mapa de pathing (transitable, edificable, sobrevolable, agua) se deriva automáticamente de las pendientes, los acantilados, el agua, las capas de suelo, los árboles y la decoración. Las herramientas de pathing pintan encima ajustes manuales, con una selección estricta en celdas de pathing. Activa la superposición en la tarjeta Pathing Overlay o con P para ver el resultado.

Ajustes de Paint Pathing

Colores de la superposición de pathing

Las reglas de la parte automática (pendientes máximas, margen de acantilado, etc.) se configuran en el componente RTS Terrain; consulta Pathing Rules.

Herramientas de marcadores

Las herramientas de marcadores añaden información de juego al mapa: dónde empiezan los jugadores, regiones con nombre para disparadores (triggers) y puntos con nombre, como posiciones de cámara. Los marcadores se dibujan en la Scene View mientras hay una herramienta de marcadores activa o la opción Show Markers está activada.

Ajustes de Start Locations

Ajustes de Regions

Las regiones nuevas reciben automáticamente un nombre único.

Ajustes de Markers

Pintado automático

Auto Paint pinta las capas de suelo a partir de la forma del terreno: hierba en el suelo llano, roca en las pendientes empinadas y junto a los acantilados, arena en la orilla y manchas de tierra fragmentadas por ruido. Es la forma más rápida de dar un aspecto acabado a un mapa recién esculpido o generado. Después puedes retocarlo a mano.

Hay tres formas de usarlo:

• la herramienta de pincel Auto Paint de la pestaña Paint pinta según las reglas dentro del pincel y mezcla el resultado con la pintura existente según el peso y la intensidad del pincel. Con Shift, pinta la capa base en su lugar, lo que elimina lo pintado por las reglas;
• la tarjeta Auto Paint Whole Map de la pestaña Paint vuelve a pintar todos los texels de suelo del mapa en un solo paso de deshacer. Tiene un campo Profile y un botón Create Profile;
• el botón Apply To Map del Inspector del perfil y la etapa Paint del generador.