RTS Terrain Studio

How a map is built

If you have used the map editor of a classic RTS game, most of these ideas will feel familiar. A map is a grid of square cells (2 m wide by default). The corners of the cells are vertices, and most data is stored per vertex or in high-resolution textures that cover the map.

In a scene, a map lives on a GameObject with the RTSTerrain component. The menu GameObject ▸ RTS Terrain Studio ▸ RTS Terrain also adds the subsystem components to it (RTSVegetationRenderer, RTSWaterRenderer and RTSDecorManager). The terrain reads the map from an .rtsmap file in your project (an RTSMapAsset). The chunk meshes, grass and water it shows are generated from that file. They are never saved into the scene, so your scenes stay small.

Your first five minutes

This is the quickest way to see everything working. It takes no setup beyond importing the package.

1. Open Tools ▸ RTS Terrain Studio ▸ Validate Project and click Fix All. This sets up URP, the fog of war renderer feature, the camera textures used by water and the colour space. A confirmation dialog explains the changes before anything is changed.
2. Run Tools ▸ RTS Terrain Studio ▸ Create Demo Content. A progress bar appears while textures, models, tilesets, maps and scenes are generated. When it finishes, the scene RTS Terrain Studio - Gameplay Demo is selected in the Project window.
3. Double-click that scene to open it, then press Play.
4. Select your units with the left mouse button (click, or drag a box) and right-click the ground to move them. Pan with WASD or the arrow keys, zoom with the mouse wheel, and press F1 to see all controls.
5. Stop Play mode and open the scene RTS Terrain Studio - Editor Playground. Open Tools ▸ RTS Terrain Studio ▸ Editor Window, choose a tool and paint in the Scene View. Hold Shift to do the opposite (for example lower instead of raise). Press Ctrl+Z to undo.
6. Open the scene RTS Terrain Studio - In-Game Editor Demo and press Play. This is the editor that your players get. Press F5 to play-test the map with units, and F2 to show or hide the editor.

Where to start

Features

Every editing tool below exists both in the Unity Editor and in the in-game editor, because both use the same tool classes (subclasses of RTSTool). The names in this list are the names you see in the user interface.

Design decisions at a glance

These are the questions people ask most often about RTS terrain tools, and how RTS Terrain Studio answers them.

A first look at the API

To give programmers an idea of the API, here is a complete script. It asks the terrain about the point you click and plans a path to it with the built-in pathfinder. It needs no colliders and no extra components: put it on any GameObject in a scene with an 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 is Success, Partial (the closest reachable point), NoPath or InvalidStart. The Scripting chapter explains the whole API.

Requirements

Folder structure

The package lives in one folder, by default Assets/RTSTerrainStudio. You can move or rename this folder: the editor finds the package root through the location of RTSTerrainStudio.Runtime.asmdef, and the demo content and documentation are found relative to it.

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)

What's included

The package ships as source code, shaders and this manual. Everything visual (textures, models, tilesets, maps and scenes) is generated on your machine by a script. This keeps the download small, and the content is licensed exactly like the code.

Demo maps

All three maps use 2 m cells, a 2 m cliff level height and the Summer tileset.

Map	Size	Symmetry	Description
Two Rivers (1v1).rtsmap	128 × 128 cells	Rotate 2	Two players, two rivers. Shallow fords cross the rivers everywhere, and the central lake is deep. Ramps lead up to forested plateaus with ruins and abandoned camps.
Four Kingdoms (4p).rtsmap	192 × 192 cells	Rotate 4	Four kingdoms, each on its own highlands. Ramps lead down into the shared lowlands, and the centre is corrupted ground with the ruins of an old temple.
Sandbox.rtsmap	96 × 96 cells	None	A small, mostly flat map for trying out the tools.

Icons

All icons in the editor window, the inspectors and the in-game editor are drawn procedurally by RTSIcons, so they stay sharp at any size and work in builds without texture assets.

Installation and setup

Open the demo scenes

The demo scenes are in RTSTerrainStudio/Samples/Scenes. Open one by double-clicking it in the Project window, or pick it in step 3 of the Welcome window and click Open.

Your first map

A map lives on an RTS Terrain GameObject in your scene and is stored in a .rtsmap file in your project. The scene only references the file; your edits are saved into the file. Start with a new scene so you can experiment freely:

1. Choose File ▸ New Scene and pick a URP scene template (for example Basic (URP)).
2. Save the scene right away with Ctrl+S, for example as Assets/MyMaps/FirstMap.unity. New map files are created next to the saved scene, so this keeps your map and scene together.

Open the editor window

Open Tools ▸ RTS Terrain Studio ▸ Editor Window (the wizard and the Welcome window can open it for you, and the RTS Terrain inspector has an Open RTS Terrain Studio button). Dock it next to the Inspector so you can see the Scene View at the same time.

Area	What it shows
Header	Terrain picker, map name (a dot means unsaved changes), Save, Save As…, Open…, Reload, Undo / Redo with the step name, a help button, and the Editing On / Editing Off toggle.
Tab bar	Eight tool categories (Height, Cliffs, Paint, Vegetation, Decor, Water, Pathing, Markers), then Map and Settings. A dot marks the category of the active tool.
Tools page	Large tool buttons, a card describing the active tool with its live status, the Brush and Symmetry cards, the tool's own settings and palettes (layers, cliff levels, players, trees, decor).
Status bar	Cursor cell, cliff level, height and pathing under the mouse, and undo memory.

The eight categories and their tools:

Key	Category	Tools
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

Every tool is described in detail in its own chapter (for example Height tools and Cliff tools); the window itself is described in Editor window.

Your first play test

There are two ways to play your map: with the Demo Game in Play Mode, or inside the running game with the in-game editor and its Play Test button.

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");
        }
    }
}

10 minute tutorial: your first 1v1 map

In this tutorial you build a small, fair map for two players: each player gets a base on a plateau with a ramp, a river separates the two halves, and forests frame the map. Symmetry painting makes sure both sides are identical, so you only build one half.

Where to go next

• Editor window: every tab, card and setting in detail, including the Map tab (resize, generator, heightmap import and export, minimap, environment).
• The tool chapters, one per category: Height, Cliffs, Paint, Vegetation, Decor, Water, Pathing, Markers.
• In-game editor: ship the editor with your game and let players build maps.
• Scripting: query heights, cliff levels and pathing from code, load maps at runtime, react to edits.
• Integrations: multiplayer with Mirror, pathfinding with the A* Pathfinding Project or Unity NavMesh.
• Troubleshooting: pink materials, flat water, painting offsets and other common problems.

The Project Validator

Open Tools ▸ RTS Terrain Studio ▸ Validate Project, or click Validate in the Welcome window. The checks run as soon as the window opens. They are grouped into four categories:

Every result has one of four statuses:

Fix All applies every available fix. A dialog first lists all changes, and nothing is modified until you click Apply Fixes. Fixes that need URP (the camera textures and the fog of war feature) run automatically after the pipeline has been assigned, so one click sets up a fresh project. Run Again repeats the checks. The full list of checks, with their fix buttons, is in Validate the project.

Running the checks from code

RTSProjectValidator.RunChecks() returns the results without changing anything, and RTSProjectValidator.FixAll() applies the fixes. You can use them in a build script or a continuous integration job. The example must be placed in an Editor folder.

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

All shaders of the package are written for URP. Without it, the terrain, water and vegetation render pink or not at all. The Use URP fix takes a URP asset of the project (or creates Assets/Settings/RTS URP.asset with a renderer), assigns it as the default render pipeline and to every quality level that uses another pipeline. To do the same by hand:

1. If the project has no URP asset yet, create one in the Project window with Create ▸ Rendering ▸ URP Asset (with Universal Renderer).
2. Assign it in Edit ▸ Project Settings ▸ Graphics as Default Render Pipeline.
3. Open Edit ▸ Project Settings ▸ Quality. For every quality level that has a Render Pipeline Asset override, check that it is a URP asset as well.

Depth Texture and Opaque Texture

Water uses the camera depth texture for shore fading and foam, and the opaque texture for refraction. Without them water looks flat. Select every URP asset your quality levels use and tick Depth Texture and Opaque Texture in its Rendering section, or click Enable Both in the validator.

The fog of war renderer feature

The RTS Fog Of War renderer feature (RTSFogOfWarRendererFeature) draws the fog over everything on screen, including units and props with your own materials. Without it only the package's own shaders show the fog. Add Feature adds it to the default renderer of every URP asset in use. To add it by hand, select the Universal Renderer Data asset, click Add Renderer Feature and choose RTS Fog Of War. The details are in Rendering: renderer feature and shader fallback.

Color space

The package is designed for Linear color space, the URP default. In Gamma space colours, lighting and water look washed out compared to the screenshots. Set Edit ▸ Project Settings ▸ Player ▸ Other Settings ▸ Color Space to Linear, or click Switch to Linear in the validator.

Required packages

The runtime assembly uses Burst (com.unity.burst), Collections (com.unity.collections) and Mathematics (com.unity.mathematics) for its jobs and data model. The package scripts do not compile while one of them is missing. Install them from Window ▸ Package Manager ▸ Unity Registry, or click Install in the validator, which adds all missing packages with one Package Manager request. The tested versions are listed in Required packages.

Input handling

All runtime input (the in-game editor, the sample camera and units) goes through the static class RTSInput. When the Input System package (com.unity.inputsystem) is installed, the runtime assembly is compiled with the define RTS_INPUT_SYSTEM and uses it. Otherwise, or when the project only uses the old Input Manager, RTSInput falls back to the old UnityEngine.Input API.

The setting is in Edit ▸ Project Settings ▸ Player ▸ Other Settings ▸ Active Input Handling. Unity asks to restart the editor when you change it. The Input handling check never changes the setting for you, because it depends on your game. See also Input handling in the requirements.

Shaders and content

• Package shaders compile. If a package shader has compile errors (affected objects render pink), Reimport re-imports it. This helps when the shaders were imported before URP finished loading. If required shaders are missing completely, re-import the package from the Asset Store. See Troubleshooting.
• Shaders included in builds. See Building your game.
• Tileset texture arrays built. Tilesets without up-to-date built arrays still work, but their arrays are built uncompressed when the map loads, which costs memory and loading time. Build Arrays builds them for every outdated tileset. See Texture arrays.
• GPU instancing on instanced prototypes. Materials of instanced trees, Mesh-mode details and instanced decor should have Enable GPU Instancing ticked. Otherwise they are drawn through temporary copies, and their instancing variants may be stripped from player builds. Enable Instancing ticks it on every listed material that can be edited. Materials inside a model or a package are read only: extract them first. See GPU instancing.
• Terrains have a tileset. A terrain without a tileset shows a neutral placeholder look. The fix assigns a tileset of the project to every terrain without one (undoable). See Tilesets.

Map files for scene terrains

An RTS Terrain keeps its map in a .rtsmap asset (its Map Asset field). A terrain without one has its map only in memory, and your edits are lost when the scene is closed. The check Terrains save to a map file lists these terrains. Create Map Files saves the current map of each listed terrain to a new .rtsmap file in the folder of its scene (or in Assets/Maps when the scene is not saved yet) and assigns it to the terrain.

Terrains made with the New Map Wizard or the demo content already have a map file. To learn how map assets, Save and Save As work, read Map assets and map files.

Building your game

Unity only puts shaders into a player build when a material in the build uses them. RTS Terrain Studio creates the terrain, water and fog of war materials from code at runtime, so the shaders are referenced from the asset Resources/RTSTerrainStudio/RTSShaderReferences.asset inside the package folder. The asset also references the DecorPlaceholder material, which keeps the instancing variants of URP Lit in the build. It is checked and updated automatically after every script reload, whenever shaders are imported and before every player build. If the check Shaders included in builds is red, click Update.

Before you build, go through this list:

1. Run Tools ▸ RTS Terrain Studio ▸ Validate Project and fix all errors and warnings.
2. Check that every quality level of your target platform uses a URP asset with Depth Texture and Opaque Texture, and that its renderer has the RTS Fog Of War feature if you use fog of war.
3. Build the texture arrays of your tilesets (Build Arrays in the validator, or Build Texture Arrays in the tileset inspector), so the terrain does not build them uncompressed at load time.
4. Validate your maps on the Map tab (see Map Validation).
5. Add your scenes to the scene list of your build profile. Maps assigned to an RTS Terrain in a scene are included like any other referenced asset.
6. If you ship the in-game editor, read Shipping the in-game editor. Maps that players save at runtime go to Application.persistentDataPath/Maps; see Map files at runtime.

The map model

All map data lives in one object of the class MapData (namespace RTSTerrainStudio). An RTSTerrain component owns one MapData (terrain.Map), renders it as chunk meshes, keeps the derived pathing map up to date and answers queries such as "how high is the ground here?".

Cells and vertices

The map is a grid of Width × Height cells. Every cell has four corner vertices, and neighbouring cells share their corners. A map of 4 × 2 cells therefore has 5 × 3 vertices:

 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)

• Vertex layers (fine height, cliff level, flags, cliff type, water height) have (Width + 1) × (Height + 1) entries, stored row by row. Use map.VertexIndex(x, z).
• Cell size (map.CellSize, default 2 m) is the world size of one cell. A 128 × 128 map with 2 m cells covers 256 × 256 m (map.WorldSize).
• A position belongs to the cell floor(localXZ / CellSize); map.LocalToCell(localXZ) does this and clamps to the map.
• For rendering, the cells are grouped into chunks (16, 32 or 64 cells per side, setting Chunk Size on the RTSTerrain component, default 32). Only chunks touched by an edit are rebuilt. The chunk size does not change the map data.

Map dimensions

The dimensions are chosen when a map is created (New Map Wizard, the in-game New Map dialog, or MapCreationSettings in code). Values outside the valid range are corrected by MapCreationSettings.Validate().

What a map contains

Every piece of data has a matching flag in the MapLayers enum. The flags are used for change notifications, undo recording and serialization.

Two combined flags are handy: MapLayers.Geometry (heights, levels, vertex flags, cliff types) and MapLayers.PathingInputs (everything that influences the pathing map). MapLayers.All covers everything.

The pathing map (terrain.Pathing, class PathingMap) is derived data: it is computed from the layers above and never saved. See Pathing map.

Cliff levels, fine heights and cliff types

Classic RTS terrain has two kinds of height: big discrete steps (cliffs) and small smooth variations (hills). RTS Terrain Studio stores both separately on every vertex.

Cliff levels

• Every vertex has a cliff level from 0 to 15 (MapData.MaxCliffLevel = 15).
• One level is CliffLevelHeight metres high (default 2 m).
• New maps start at level 2, so there are two levels below the ground for lakes, rivers and canyons, and thirteen above it for plateaus.
• Edit levels with the cliff tools: Raise / Lower Level, Set Level, Ramp, Cliff Type and Clean Cliffs.
• The fog of war uses cliff levels for line of sight: units see their own level and below, higher ground blocks their sight.

Fine heights

On top of the level, every vertex has a fine height in metres (Heights), positive or negative. The height tools (Raise / Lower, Smooth, Flatten, Set Height, Noise, Terrace, Erode) change only the fine height, so you can build hills on a plateau without turning them into cliffs. The ground height of a vertex is:

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

Example: level 3 with a level height of 2 m and a fine height of 0.4 m gives a vertex 6.4 m above the map origin. map.GetVertexHeight(x, z) and map.GetVertexPosition(x, z) compute this for you.

Cliff types

A tileset can have up to 4 cliff layers (for example "Rock" and "Grassy Cliff"). Every vertex stores which one to use (CliffTypes, 0–3, painted with the Cliff Type tool). A cliff wall uses the cliff type of the highest corner of its cell. If a cliff type index has no layer in the tileset, the wall falls back to cliff layer 0.

How the surface is built (the reference surface)

The struct MapGeometryView defines the one true surface of the terrain. The chunk meshes, the gameplay queries (GetHeight, Raycast, …), the pathing map and the fog of war all follow the same rules, so what you see is what units walk on. Each cell is classified by its four corners:

Rounded contours. Inside a cliff cell, for every level threshold t the indicator "corner level ≥ t" (1 or 0) is interpolated bilinearly across the cell. A point belongs to the highest level whose interpolated indicator is at least 0.5 (MapGeometryView.LevelAt). This is a marching-squares rule: a single raised corner produces a quarter circle instead of a diagonal, and long cliff lines stay straight. The wall itself is vertical at the contour. The fine heights are always interpolated bilinearly and added on top, also inside cliff cells.

The look of the rendered walls is tuned on the RTSTerrain component (Settings):

Get a view with map.GetGeometryView(). It is a struct of native arrays, so you can also pass it into Burst jobs. All members take map-local positions:

Ramps

A ramp lets units walk from one cliff level to the next. The rule is simple:

• The flag is VertexFlags.Ramp on each vertex. The Ramp tool (id cliff.ramp) paints it; hold Shift to remove it.
• A ramp cell is a smooth bilinear slope between its corner heights (level plus fine height).
• Ramps work best across exactly one level. Steeper ramps are allowed, but the status bar warns about ramp cells that span more than one level.
• Pathing: a valid one-level ramp is tested for walkability on its fine-height slope only (the level incline it bridges does not make it "too steep"). Ramps are never buildable.
• GetCliffLevel on a ramp returns the interpolated level, rounded: the lower level on the lower half, the upper level on the upper half.

1. Raise a plateau by one level with Raise / Lower Level.
2. Select the Ramp tool and paint across the cliff edge where the ramp should be. Make the brush cover at least the vertices on both sides of the wall, so that every corner of the cells in between is flagged.
3. The wall disappears and a slope appears. Widen the ramp by painting more vertices along the edge.

Ground layers and splat maps

Ground textures are painted into splat maps: four RGBA textures (MapData.SplatMapCount = 4) of SplatWidth × SplatHeight texels. Each of the 16 channels holds the weight of one ground layer of the tileset:

• Layer i is stored in map i / 4, channel i % 4. That is why a tileset has exactly 16 ground layers: 4 maps × 4 channels.
• The weights of one texel always sum to 255 across all 16 channels. All paint tools keep this invariant; code that writes splat data must keep it too.
• The splat resolution is the number of texels per cell side (default 4). With 2 m cells that is one texel every 0.5 m.
• The centre of texel (x, z) is at ((x + 0.5), (z + 0.5)) × CellSize / SplatResolution in map-local XZ. The same formula applies to detail and pathing texels with their own resolution.
• Helpers: map.SplatIndex(x, z), map.GetSplatWeight(texelIndex, layer), map.GetDominantLayer(texelIndex), MapData.GetChannel / SetChannel and 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));
    }
}

Water

• A vertex is under water when it has the flag VertexFlags.Water. Its water surface height (map-local Y, metres) is stored in WaterHeights; the value is only meaningful where the flag is set.
• A point is wet when the bilinear coverage of the four flagged corners of its cell is at least 0.5. Corners without water inside a wet cell use the highest water height of the cell, so shorelines stay level.
• Water depth = water surface − ground height. Depth decides pathing: water deeper than the tileset's Shallow Depth Limit (default 0.9 m) is deep water (not walkable), shallower water is shallow water (walkable, not buildable by default).
• The water tools are Paint Water, Erase Water and Flood Fill. Water edits only notify MapLayers.Water, so terrain chunks are not rebuilt while you paint water.
• Queries: terrain.IsWater(world, out depth) and terrain.TryGetWaterHeight(world, out waterWorldY).

The look of water (colours, waves, foam) comes from the tileset's water profile; see Water profile.

Detail density (grass and small plants)

• Details are not individual objects. Each detail prototype that is used on the map has one DetailLayer in map.DetailLayers: a byte per detail texel (DetailWidth × DetailHeight, default 2 texels per cell side).
• A density of 0 means empty, 255 means Max Density instances per texel (a field of the detail prototype, default 6). Every texel spawns density / 255 × maxDensity instances; the renderer scatters them deterministically, so the same map always looks the same.
• Layers are matched to the vegetation library by prototypeId. map.GetOrAddDetailLayer(id) creates a layer on demand; map.FindDetailLayer(id) returns null when the prototype is not used.
• Paint with Paint Details, remove with Erase Details.

Trees and decor instances

Trees (TreeInstanceData) and decor objects (DecorInstanceData) are stored as plain lists. Instead of a prototype name, every instance stores a small palette index into a list of library ids on the map:

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

• Use map.GetOrAddTreePrototype(id) / map.GetOrAddDecorPrototype(id) to get the palette index of a library id (it is added when missing).
• Because maps reference prototypes by id, you can rename, reorder or extend a library safely. A prototype that is missing from the library is skipped by the vegetation renderer and shown as a magenta placeholder cube by the decor manager; adding a prototype with the same id brings it back. Pathing: trees with a missing prototype are not drawn but still block a circle of PathingMapBuilder.DefaultTreeFootprintRadius (0.8 m) × scale. Decor placeholders do not write a pathing footprint until the prototype is back.
• Every instance has a unique, stable id within the map. Get new ids with map.AllocateInstanceId().
• Positions are map-local. Rotations follow one convention everywhere: degrees, clockwise seen from above, 0 = +Z, 90 = +X (the same as Unity's Y rotation).

The position.y convention

Never copy the prototype's yOffset into position.y; it is added at render time. DecorMath.ComputeLocalPosition and DecorMath.ToStoredHeight convert between stored and rendered positions.

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;
    }
}

Pathing map

The pathing map answers "can a unit walk here, can a building stand here?". It is a grid of pathing cells (PathingResolution per map cell side, default 2, so 1 m pathing cells on a map with 2 m cells) with one PathingFlags byte each. It is derived automatically and rebuilt incrementally whenever an input changes (geometry, water, ground layers, trees, decor, overrides). It is never saved: only the manual overrides are.

How the flags are derived

1. Terrain: cliff walls (plus the Cliff Margin) set Cliff; slopes above Max Walkable Slope (default 42°) set Steep; water sets ShallowWater or DeepWater by depth; Flyable is set everywhere; Buildable = walkable, slope ≤ Max Buildable Slope (default 18°) and dry (or shallow water when Shallow Water Buildable is on). Then the Pathing Effect of the dominant ground layer is applied (for example "Unbuildable" on rough rock).
2. Footprints: trees block a circle (Footprint Radius × tree scale × Tree Footprint Scale); decor applies its Footprint Effect inside a circle or a rotated box, unless the instance has DecorFlags.IgnorePathing.
3. Manual overrides painted with Paint Pathing / Clear Pathing are applied last.

The rule settings live on the RTSTerrain component (RTSPathingSettings, property terrain.PathingSettings).

The same PathingOverride flags are used for ground layer pathing effects, decor footprint effects and painted overrides. Query the result with terrain.GetPathing(world), terrain.IsWalkable(world) and terrain.IsBuildable(world), or read terrain.Pathing.Flags directly.

Regions, start locations and markers

These are lightweight objects for your game logic. They are not rendered in the game; the editors draw them as gizmos.

The tools store position.y = 0 for start locations and markers and treat it as an offset above the ground, like trees.

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;
    }
}

Map info and environment

EnvironmentSettings stores the lighting of a map. It is applied to the scene by an RTSEnvironment component (GameObject ▸ RTS Terrain Studio ▸ Environment); without one, the values are saved but not used.

Change notifications

When you change MapData from code, tell the terrain what changed and where, in cells:

• terrain.NotifyChanged(MapLayers layers, RectInt cellRect) raises MapChanged immediately and queues the rebuild.
• terrain.NotifyChangedAll(layers) marks the whole map (after generators or imports).
• Pending changes are processed in LateUpdate (and every editor tick outside Play Mode), or immediately with terrain.ProcessPendingChanges(). Afterwards ChangesProcessed fires: meshes, textures and pathing are up to date.
• A vertex touches up to four cells. Convert a rectangle of vertices with BrushUtility.VertexRectToCellRect(map, vertexRect), and texel rectangles with 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);
    }
}

Coordinates and multiple terrains

All map data is stored in map-local space. The RTSTerrain GameObject's transform places that space in the world.

Map-local space

• The origin is vertex (0, 0), the corner of cell (0, 0). X and Z run from 0 to map.WorldSize in metres, Y is up.
• Vertex (x, z) is at local (x × CellSize, height, z × CellSize); cell (x, z) has its centre at ((x + 0.5) × CellSize, …, (z + 0.5) × CellSize).
• Local Y = 0 is level 0 with a fine height of 0. A new map at base level 2 with 2 m levels has its ground at local Y = 4 m.
• The chunk GameObjects live under a hidden RTS Chunks child of the terrain (RTSTerrain.ChunkRoot). That root has no local offset or rotation and compensates the terrain's scale, and each chunk has an identity local transform, so the object space of chunk meshes is map-local space. This matters when you write shaders for the terrain.

Converting between world and map space

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)}.");
    }
}

Position, rotation and scale rules

Multiple terrains

A scene can contain any number of RTSTerrain components. Each one has its own map, tileset, libraries, chunks and pathing map.

• RTSTerrain.All lists all enabled terrains; RTSTerrain.Main returns the first one (handy for single-map games; temporary preview terrains are skipped).
• RTSTerrain.FindAt(worldPosition) returns the terrain whose XZ area contains a position.
• RTSTerrain.RaycastAll(ray, out hit) ray casts against all terrains and returns the closest hit (hit.terrain tells you which).
• RTSTerrain.TerrainEnabled / TerrainDisabled are static events for systems that track terrains.
• Terrains are independent: maps are not stitched at their borders, and pathfinding (RTSPathfinder.FindPath(terrain, …)) works on one terrain at a time. To make two maps meet seamlessly, give their border vertices the same heights.

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);
    }
}

Map assets and map files

A map is saved as a .rtsmap file. The same binary format is used in the Unity Editor (as an asset in your project) and by the in-game editor (as a file on disk), so maps made by players can be opened in Unity and the other way round.

.rtsmap files in the project

When Unity finds a .rtsmap file in the Assets folder, the importer RTSMapImporter turns it into an RTSMapAsset. The asset stores the compressed file bytes, a small header (name, author, size, players, tileset id) and a minimap preview that is also used as the thumbnail in the Project window.

Creating a map asset

• Tools ▸ RTS Terrain Studio ▸ New Map Wizard...: guided setup (basics, size, look, terrain); writes the file and creates a terrain for it, or assigns it to the selected terrain.
• Assets ▸ Create ▸ RTS Terrain Studio ▸ Map (.rtsmap): creates a flat 128 × 128 map with default settings in the selected folder.
• Save As… in the RTS Terrain Studio window: writes the current map of a terrain to a new file.
• Copy a .rtsmap file made with the in-game editor into the Assets folder; it is imported like any other file.

The map asset inspector

Select a map asset to see its preview, name, author, description, size, players, tileset and format version, plus statistics (cells, world size, cell size, level height, start locations, trees, decor, regions, markers, detail layers, file size, memory, last modification).

The preview is re-baked automatically when the tileset with the map's id is added, removed or changes its minimap colours. Rebuilding texture arrays does not re-import maps. A damaged file is imported as an empty asset with an error icon and an import error in the console.

Editing, Save and Save As

Assign a map asset to the Map Asset field of an RTSTerrain. When the terrain is enabled it loads the map into memory, and all edits happen on that in-memory copy. The scene file only stores the reference to the asset, never the map data itself.

• Save (RTS Terrain Studio window header, or Save Map in the options menu of the RTS Terrain Studio Scene View overlay) writes the map back into its .rtsmap file and re-imports it. Save is highlighted while there are unsaved changes.
• Save As… writes a new file and assigns it to the terrain without reloading, so your undo history is kept.
• Open… loads another map asset; Reload reloads the map from its asset and discards unsaved changes.
• A terrain without a map asset creates a map from its Default Map Settings. That map exists only in memory until you use Save As.
• Saving the scene (Ctrl+S) also saves the edited maps of the terrains in that scene, and offers Save As for new maps without a file. Both behaviours can be switched off in the options menu of the Scene View overlay (Save Maps When Saving the Scene, Offer Save As for New Maps).
• Before entering Play Mode, closing a scene or quitting Unity with unsaved map edits, you are asked whether to save them. Edits made in Play Mode (Scene View tools or the in-game editor) are also offered for saving when you exit Play Mode.

Map files at runtime

In a built game, maps are plain files on disk:

• RTSMapSerializer.DefaultMapsFolder is Application.persistentDataPath/Maps (on Windows typically %USERPROFILE%\AppData\LocalLow\<Company>\<Product>\Maps).
• The in-game editor (RTSRuntimeEditor) saves and opens maps in its Maps Folder (empty = the default folder above; relative paths are relative to Application.persistentDataPath). With Write Preview Images on, it writes a small minimap image Name.preview.png next to every saved map for its map browser.
• To share a map, copy the .rtsmap file into another player's maps folder, or into a Unity project.
• Maps you ship with the game can simply be map assets referenced by a terrain or a script; they are included in the build like any other 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

A tileset (RTSTileset) defines the look of a map: up to 16 ground layers, up to 4 cliff layers and the water style, comparable to the summer, winter or desert tilesets of classic RTS map editors. You can have any number of tilesets and switch the tileset of a terrain at any time: painted maps only store layer indices, so the same map can be shown in summer and winter.

1. Create a tileset with Assets ▸ Create ▸ RTS Terrain Studio ▸ Tileset.
2. Drag your ground textures onto the Ground Layers section of the inspector. One layer is created per albedo texture. Matching normal and height maps are picked up by their file name suffix (for example _n, _normal, _nrm, _normalgl, _h, _height, _disp); roughness, AO and metallic maps are ignored, so you can drop a whole downloaded texture folder.
3. Add cliff layers in Cliff Layers the same way.
4. Assign the tileset to the Tileset field of your RTSTerrain.
5. Click Build Texture Arrays in the Texture Arrays section once (see Texture arrays).

Tileset fields

Ground layer fields

Cliff layer fields

Cliff walls are textured triplanar in map-local space, so cliff textures need no special UV layout.

Water profile

The water profile is part of the tileset and is used by the water renderer, the pathing map and the minimap.

Editing tilesets from code

Tilesets are ScriptableObjects. After changing fields from code, call tileset.NotifyChanged() so terrains refresh their materials. tileset.GetGroundLayer(index) and GetCliffLayer(index) return null for unused slots.

Texture arrays

The terrain shader draws all 20 layers in a single pass, so all layer textures are packed into two GPU texture arrays. You never author these arrays yourself: plain Unity textures of any size and format go in, the arrays come out.

Layout

• The first cliff slice is RTSTileset.CliffSliceOffset (16); the total is RTSTileset.TotalSlices (20).
• Height (alpha) comes from the layer's Height Map (R channel), else from the albedo alpha when Height From Albedo Alpha is on, else a constant 0.5.
• Normals are unpacked during the build, so your normal maps can use Unity's normal map import (DXT5nm / BC5) as usual. Layers without a normal map get a flat normal.
• Layers without an albedo get a neutral grey slice with a subtle pattern; the tint is still applied by the shader.
• Every slice has a full mip chain and uses trilinear filtering. Sources of any size are resized to the chosen Resolution.

Built arrays and the runtime fallback

There are two ways the arrays come into existence:

The Texture Arrays section shows a status badge:

• Not built: the terrain uses runtime arrays. Click Build Texture Arrays once.
• Up to date: format, size, mip count and memory are shown.
• Outdated: textures, resolution or compression changed, or the arrays were built for another platform. Rebuild.
• Building: a build is running or scheduled.

The section also shows the target format for the active build platform, the estimated size and build time, and asks for confirmation before builds larger than 256 MB. Clear removes the built arrays.

From code: tileset.HasValidBuiltArrays tells you whether the compressed arrays will be used (they exist and match ComputeContentHash()). When it is false, RTSTerrain builds uncompressed runtime arrays (RTSTextureArrayBuilder.Acquire). tileset.BuiltAlbedoArray / BuiltNormalArray expose the built arrays. Use RTSShaderReferences.FindShader(name) (and FindMaterial(name)) instead of Shader.Find in your own runtime code, so the lookup also works in player builds.

Auto Build

With Auto Build on (the default, an editor preference for all tilesets), arrays that were built before are rebuilt one second after textures, resolution or compression change, using fast compression. The first build is always started by hand. A cancelled or failed auto build is not retried until the content or the target format changes. The explicit Build Texture Arrays button uses normal compression quality, which looks slightly better, so press it before you ship.

Vegetation library

A vegetation library (RTSVegetationLibrary) lists the grass, plants and trees available for painting. Create one with Assets ▸ Create ▸ RTS Terrain Studio ▸ Vegetation Library and assign it to the Vegetation Library field of the RTSTerrain. The terrain also needs an RTSVegetationRenderer component to show vegetation (the RTSTerrain inspector offers to add it).

The inspector has two tabs, Details and Trees, with a grid of thumbnails. Drop prefabs (trees), textures (grass cards) or meshes (detail meshes) onto it to add entries. Every entry gets a stable id that maps use; duplicated entries automatically get new ids.

Detail prototypes

Details are small, numerous plants painted by density (see Detail density). They are generated in patches of 16 × 16 cells and drawn with the internal procedural shader Hidden/RTS Terrain Studio/Detail, which handles wind, fog of war and colour variation.

Tree prototypes

Trees are individual instances (see Trees and decor instances) placed with Place Trees.

GPU instancing

Instanced trees are drawn with GPU instancing, so their materials should have Enable GPU Instancing switched on. If a material has it off, the renderer uses a hidden instancing copy of it automatically (kept in sync with the original while you edit), and the library inspector shows an info message with an Enable button that fixes the material itself. Details do not need instancing on their materials, because they are always drawn with the procedural detail shader.

From code, tree instances are removed with RTSVegetationRenderer.RemoveTree(id) (for example when a worker harvests a tree), found with TryFindNearestTree, and their GameObject or collider proxy is returned by GetTreeObject(id).

Editing libraries from code

Maps store a palette of prototype ids, so resolve a palette index through the library:

• Trees: vegetationLibrary.FindTree(map.TreePrototypeIds[tree.prototype]).
• Detail layers: vegetationLibrary.FindDetail(layer.prototypeId).
• Decor: decorLibrary.Find(map.DecorPrototypeIds[d.prototype]). Get the variant prefab with prototype.GetPrefab(d.variant): 0 is the main prefab, and invalid or empty variants fall back to it. VariantCount includes the main prefab.
• decorLibrary.GetCategories() lists the categories in display order (prototypes without a category are listed as Misc).
• vegetationLibrary.EnsureUniqueIds() gives duplicated entries new ids.

After changing a library from code, call library.NotifyChanged() (it raises the library's Changed event), so RTSTerrain raises LibrariesChanged and the renderers refresh. This is the same rule as for tilesets.

Decor library

A decor library (RTSDecorLibrary) lists the props (doodads) you can place: rocks, ruins, fences, crates, buildings or any other prefab. Create one with Assets ▸ Create ▸ RTS Terrain Studio ▸ Decor Library and assign it to the Decor Library field of the RTSTerrain. An RTSDecorManager component on the terrain keeps the scene in sync with the placed instances.

The inspector shows the prototypes as a grid with auto-generated thumbnails and one tab per category (plus All). Drop prefabs onto it to add them to the current category; right-click a category tab to rename it. Prototypes without a category appear under Misc.

Decor prototype fields

Footprints

• A circle footprint uses Footprint Size X as radius, multiplied by the largest horizontal scale of the instance.
• A box footprint follows the instance's rotation (its X and Z axes projected onto the ground) and its X/Z scale, so a rotated wall blocks exactly its own area.
• No footprint is written when the shape is None, the effect is None, or the instance has the flag DecorFlags.IgnorePathing.
• Use Unbuildable alone for flat decorations units may walk over (flowers, rubble), and Unwalkable for solid objects.

Spawn modes

Instanced decor has the same GPU instancing behaviour as instanced trees: materials without Enable GPU Instancing are drawn through a hidden instancing copy. Spawned objects are pooled; RTSDecorManager.GetInstanceObject(id) returns the spawned object of an instance, and RTSDecorInstance.FromCollider(collider) maps a physics hit back to its instance.

The .rtsmap file format

This section is for programmers who want to read maps with other tools, write converters or add their own data. You do not need it to use the package: RTSMapSerializer handles everything.

Binary layout

All numbers are little-endian. Strings use the .NET BinaryWriter format: a 7-bit encoded length followed by UTF-8 bytes.

The header is uncompressed so map browsers can show name, author, size and players without decompressing the map (RTSMapSerializer.TryReadHeader, TryReadHeaderFromFile, struct RTSMapHeader). Readers jump to the end of the header using the header length, so future versions can append header fields.

Sections

Every section is [int32 tag][int32 length][payload]. Tags are FourCC codes stored little-endian, so the first character is in the lowest byte (DIMS = 0x534D4944). Arrays of raster data are written as an int32 element count followed by the raw elements.

"Properties" are written as an int32 count followed by key/value string pairs. The derived pathing map is not stored; only the manual overrides are.

Unknown sections, damaged files and versioning

• Unknown sections are skipped using their length. Older versions of the package can therefore read newer files with additional sections, and your custom sections never break other readers.
• A file with a newer format version than the reader logs a warning and is read anyway; unknown data is skipped.
• A raster layer whose element count does not match the map size logs a warning; what fits is read, the rest is skipped.
• Truncated or damaged files throw a single exception type, System.IO.InvalidDataException. A file with the wrong magic is reported as "Not an RTS Terrain Studio map file".
• RTSMapSerializer.SaveToFile writes to <path>.tmp first and then replaces the file, so a crash during saving never leaves a half written map behind.
• Compatibility rule for the format: new data is added as new sections or appended header fields, never by changing existing sections. Do the same with your own sections and keep a version number inside your payload.

Custom sections

You can store your own data in map files, for example game rules, triggers or quest data. Two static hooks on RTSMapSerializer make this possible:

• Choose tags that do not collide with the built-in ones; start them with X (for example XGLD). Never use 0, which marks the end of the sections.
• Both hooks are plain delegates: combine handlers with += and remove them with -=, so several systems can add sections.
• Check the tag in your reader and ignore sections that are not yours.
• MapData has no slot for your data. Keep it next to the map (the example uses a ConditionalWeakTable). Data kept this way is not copied by MapData.Clone() or ResizeMap, and is not recorded for undo.
• Register the hooks before any map is loaded or saved. In the Unity Editor, maps are also read by the importer and written by Save, so register for the editor as well (the example uses 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();
        }
    }
}

Use it in game code with StartingGoldSection.Get(terrain.Map).startingGold. After changing the value in the editor, mark the map as changed (for example terrain.NotifyChanged(MapLayers.Info, terrain.Map.CellBounds), or set terrain.HasUnsavedChanges = true) so that it gets saved.

The RTS Terrain Studio window

The window is the control centre of the editor. It holds no editing state of its own: it shows and changes the shared edit session that the Scene View, the Scene View overlay and the RTS Terrain inspector use as well. Anything you change in one place shows up immediately in the others.

You can open it in any of these ways:

• Tools ▸ RTS Terrain Studio ▸ Editor Window
• the Open RTS Terrain Studio button in the RTS Terrain inspector
• the window button in the RTS Terrain Studio overlay of the Scene View

The window has four areas: the header at the top, the tab bar, the scrollable page, and the status bar at the bottom.

Tool pages

Each category tab shows a stack of cards. Every card can be collapsed by clicking its header.

Card	Contents
Category Tools	The tool grid. Click a tool to paint with it in the Scene View. Click the active tool again to stop editing. Hover a tool to read its description and modifier keys. Custom tools you write appear here automatically.
Tool card	The name, description and hint of the selected tool, a ? button that opens the matching section of this manual, and a live status line. Move the mouse over the terrain to see it, for example Ground 4.25 m | Fine +0.25 m | Level 2 for height tools or Level 2 → 3 for the cliff tools.
Getting Started	Shown when no tool of this category is selected. If you are painting with a tool of another category, it says Active tool: X and offers Go to Tool.
Brush	Shape, radius, strength, hardness, falloff curve, rotation, random rotation, spacing and jitter. These settings are shared by all brush tools. Hidden for tools that do not use the brush. See Brushes.
Symmetry	Symmetry mode and centre (not shown for drag tools). See Symmetry.
Tool Settings	The settings of the selected tool, built automatically from the tool's code. They are remembered between editor sessions. The tables in the tool reference list every setting.
Category actions	Extra cards for some categories: Auto Paint Whole Map (Paint), Selection (Decor, while Select Decor is active), Water at Cursor (Water) and Pathing Overlay (Pathing).

While editing is paused, a banner says Editing is paused – the Scene View uses Unity's tools. Its Resume button turns editing on again.

Map tab

The Map tab holds map-wide settings and operations. Every change can be undone, unless its dialog says otherwise. The ? button at the top opens this section.

Settings tab

Painting in the Scene View

All editing happens in the Scene View. When terrain editing is on and a tool is selected, the left mouse button paints with the tool instead of selecting objects. Turn editing on with the window's Editing button, the overlay's Start Editing button, the inspector's Edit Terrain button, or by clicking a tool. Turn it off with 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 ...
        }
    }
}

Keyboard shortcuts

The Scene View shortcuts are registered in Unity's Shortcut Manager under the category RTS Terrain Studio. They are active only while terrain editing is on, a Scene View or one of the RTS Terrain Studio editor windows has keyboard focus (or the mouse is over a Scene View), and you are not typing in a text or number field. Outside editing, keys such as R or the number keys keep their normal Unity meaning.

These keys and mouse actions are handled by the package itself and cannot be rebound:

The following keys are Unity's own shortcuts and commands. RTS Terrain Studio reacts to them, but they follow whatever you bind to them in Edit ▸ Shortcuts... under Unity's categories (Main Menu/Edit, Tools):

R with Select Decor is the package's own RTS Terrain Studio/Toggle Random Rotation entry: while Select Decor is active it switches to Unity's Scale tool instead of toggling random rotation.

Brushes

All brush tools share one brush. You set it on the Brush card of any tool page, in the overlay (Size and Strength) or with the shortcuts. The brush is remembered between editor sessions.

Symmetry

Symmetry repeats every dab, click and placed object at mirrored or rotated positions. It is how you build fair competitive maps: every player gets the same hills, cliffs, ramps, trees and gold mines. Choose the mode on the Symmetry card or in the overlay. Magenta guides in the Scene View show the axes and the centre.

Centre is the symmetry centre in normalized map coordinates: (0.5, 0.5) is the map centre and the default. Reset moves it back. If you move the centre, some copies may fall outside the map and are skipped; the card shows a warning.

Undo and redo

Every terrain edit is recorded in the map's own undo history, which is linked to Unity's undo system. Ctrl+Z, Ctrl+Y and the Edit ▸ Undo menu work for terrain edits exactly like for any other change, and the Edit menu shows the step name, for example Undo Raise / Lower. The Undo and Redo buttons in the window header do the same and keep Unity's history in step. Undoing a change to another object in between does not disturb the terrain history.

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);
        });
    }
}

Tool reference

The following sections describe every tool of the eight categories. All tools work the same way in the Unity Editor and in the in-game editor. Some conventions apply to all of them:

• Id is the tool's unique id. Use it in code, for example RTSEditorContext.ActivateTool("height.raise").
• Input: Brush tools paint while you drag. Click tools act once per click. Drag tools use press, drag and release (rectangles, box selection).
• Repeats: dabs per second while you hold the button without moving.
• Shift inverts and Ctrl+click picks, where the table says so.
• Every setting is listed with its range and default. Settings are remembered between editor sessions. Reset All Tool Settings on the Settings tab restores the defaults.

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);
    }
}

Height tools

Height tools sculpt the fine height: hills, valleys, roads and natural detail on top of the cliff levels. They never change cliff levels, so cliff walls stay crisp. The status line shows the ground height, fine height and cliff level under the cursor.

Raise / Lower settings

Smooth settings

Flatten settings

Set Height settings

Noise settings

Terrace settings

Erode settings

Cliff tools

Cliff tools change the cliff level of vertices (0–15) and the look of the cliff walls between levels. The brush snaps to vertices and acts as a hard selection, so you paint whole vertices, never half levels. The status line shows the hovered level and the level you are about to paint, for example Level 2 → 3.

Raise / Lower Level settings

The target level is taken from the vertex under the cursor when the stroke starts: one level higher (or lower with Shift). Dragging paints that same level, so you can extend a plateau without stacking levels. The tool only raises (or only lowers) vertices.

Set Level settings

Ramp

Ramp has no settings. A cell becomes a ramp when all four of its corner vertices are flagged as ramp and the cell spans a level difference of exactly one. The status line helps: it counts the valid ramp cells under the brush, mentions flagged cells without a level difference, and warns when a ramp spans more than one level (it would be stretched).

Cliff Type settings

Clean Cliffs settings

Automatic cliff edges

In classic RTS map editors, raising a cliff also changes the ground next to it. The cliff tools do the same: when a stroke ends, the ground along every new cliff edge is painted with the edge ground layer of the cliff type, for example a stony "Rocky Dirt" rim. The rim follows the rounded cliff outline, fades out over the Edge Width and has a slightly irregular outline, so it looks natural rather than cell-shaped.

1. Select the tileset and open Cliff Layers. On each cliff card choose an Edge Layer (the demo tilesets use Rocky Dirt).
2. Pick Raise / Lower Level, Set Level, Ramp or Clean Cliffs and keep Paint Cliff Edges switched on.
3. Paint cliffs as usual. The rim appears when you release the mouse button.

• One undo step: the level change and the edge paint are undone together.
• Symmetry: all symmetric copies get their edges in the same pass.
• Ramps: ramp cells never get a rim. Painting a ramp across an edge removes the rim there when Clean Up Old Edges is on.
• Moved cliffs: with Clean Up Old Edges on, the rim of an edge that disappeared (a lowered plateau, an extended plateau) is removed again. This also removes the edge layer if you painted it there by hand.
• Optional: switch Paint Cliff Edges off for a tool, or set the cliff type's Edge Layer to None for the whole tileset. When the option is on but no edge layer is set, the status line says so.

Paint tools

Paint tools paint the ground layers of the tileset (up to 16). Each splat texel stores the weights of all layers, which always add up to 100 %. When the selected layer is missing in the tileset or has no texture, the status line says so instead of painting silently with a fallback.

Paint Layer settings

Tile Paint settings

Fill / Replace settings

Each click is one undo step that records only the area that actually changed.

Smooth Paint settings

Auto Paint settings

The Paint tab also shows the Auto Paint Whole Map card, which repaints the entire map from the profile in one step.

Vegetation tools

Vegetation tools paint grass and small plants (details) and place trees from the terrain's Vegetation Library. If the terrain has none, the tool page offers Create Vegetation Library. Pick prototypes in the grid; with none selected, the first prototype of the library is used.

Paint Details settings

Erase Details settings

Place Trees settings

Erase Trees settings

Decor tools

Decor tools place, erase and edit props such as rocks, ruins and fences from the terrain's Decor Library. If the terrain has none, the tool page offers Create Decor Library. The prototype grid has a search field and category filters.

Place Decor settings

Erase Decor settings

Select Decor settings

Selection card

While Select Decor is active, the Decor tab shows the Selection card with the number of selected objects. Every editing button (Delete, Duplicate, Snap to Ground, Rotate 90°, Lock, Unlock) is one undo step. Select All and Clear only change the selection.

Moving, rotating and scaling with handles is described in Decor selection handles.

Water tools

Water is stored per vertex: a vertex is either wet, with a water surface height, or dry. The water tools use a hard selection, like the cliff tools. The Water at Cursor card shows the water level and depth under the mouse and whether it counts as shallow (walkable) or deep water, based on the tileset's shallow water limit.

Water height settings (Paint Water and Flood Fill)

Paint Water settings

Flood Fill settings

Pathing tools

The pathing map (walkable, buildable, flyable, water) is derived automatically from slopes, cliffs, water, ground layers, trees and decor. The pathing tools paint manual overrides on top, with a hard selection in pathing cells. Turn on the overlay on the Pathing Overlay card or with P to see the result.

Paint Pathing settings

Pathing overlay colours

The rules used for the automatic part (maximum slopes, cliff margin and so on) are set on the RTS Terrain component; see Pathing Rules.

Marker tools

Marker tools add gameplay information to the map: where players start, named regions for triggers, and named points such as camera positions. Markers are drawn in the Scene View while a marker tool is active or Show Markers is on.

Start Locations settings

Regions settings

New regions get a unique name automatically.

Markers settings

Auto Paint

Auto Paint paints the ground layers from the shape of the terrain: grass on flat ground, rock on steep slopes and along cliffs, sand at the shore, dirt patches broken up by noise. It is the fastest way to make a freshly sculpted or generated map look finished. You can then refine it by hand.

There are three ways to use it:

• the Auto Paint brush tool on the Paint tab paints the rules inside the brush and blends them with the existing paint by brush weight and strength. Shift paints the base layer instead, which removes rule painting;
• the Auto Paint Whole Map card on the Paint tab repaints every ground texel of the map in one undo step. It has a Profile field and a Create Profile button;
• the Apply To Map button in the profile's Inspector, and the generator's Paint stage.

Without a profile, built-in default rules are used. They pick their layers by the names of the tileset's ground layers.

using RTSTerrainStudio;
using UnityEngine;

// Repaints the whole map with a profile, for example after your own procedural edits.
public class RepaintWithProfile : MonoBehaviour
{
    public RTSTerrain terrain;
    public RTSAutoPaintProfile profile;

    void Start()
    {
        if (terrain == null || terrain.Map == null || profile == null) return;

        // Evaluates the rules for every splat texel inside the rectangle (here: the whole map).
        RTSAutoPaint.Apply(terrain.Map, profile, terrain.Map.CellBounds);

        // Let the terrain upload the new splat maps and update dependent systems (pathing ground rules).
        terrain.NotifyChangedAll(MapLayers.Splat);
        terrain.ProcessPendingChanges();
    }
}

The RTS Terrain component

The RTS Terrain component shows one map. It builds the terrain mesh in chunks, renders the ground and cliffs with the tileset, keeps the pathing map up to date and offers queries such as height, water and pathing at a world position. Create it with GameObject ▸ RTS Terrain Studio ▸ RTS Terrain, or add it to any GameObject with Add Component ▸ RTS Terrain Studio ▸ RTS Terrain.

The menu item creates a ready-to-edit terrain: an RTS Terrain GameObject with the RTS Terrain, Vegetation Renderer, Water Renderer and Decor Manager components, the default tileset and libraries of the project, and a new flat .rtsmap file next to the active scene (or in Assets/Maps). If the project has no tileset yet, you are offered to create the demo content first.

using RTSTerrainStudio;
using UnityEngine;

public class TerrainQualityOptions : MonoBehaviour
{
    public RTSTerrain terrain;

    // Called from a graphics options menu, for example.
    public void SetSmoothHills(bool smooth)
    {
        // Settings fields can be changed directly, but the chunks are only rebuilt on request.
        // Use 1, 2 or 4: an odd value such as 3 rounds Cliff Subdivisions up to a multiple of 6 (expensive).
        terrain.Settings.surfaceSubdivisions = smooth ? 2 : 1;
        terrain.RebuildAll();
    }

    public void UseStricterSlopes()
    {
        // Assigning new pathing settings rebuilds the pathing map automatically.
        RTSPathingSettings rules = terrain.PathingSettings.Clone();
        rules.maxWalkableSlope = 35f;
        rules.maxBuildableSlope = 12f;
        terrain.PathingSettings = rules;
    }
}

Try it in two minutes

The quickest way to see the in-game editor is the demo scene that comes with the package.

1. Choose Tools ▸ RTS Terrain Studio ▸ Create Demo Content. This generates the demo textures, libraries, maps and scenes. You only need to do this once.
2. In the Project window, open Samples/Scenes/RTS Terrain Studio - In-Game Editor Demo. It contains the Sandbox map, an RTS In-Game Editor object, an RTS Demo Game object and a fog of war manager.
3. Press Play. The editor opens with a welcome hint. Pick a tool on the left (the Raise / Lower height tool is active by default) and paint on the terrain with the left mouse button.
4. Hold Shift while painting to lower the ground. Use [ and ] to change the brush size. Drag with the right mouse button to move the camera and use the mouse wheel to zoom.
5. Press F5 (or Play Test in the top bar). The demo game spawns units at the start locations and switches on the fog of war. Select units and right-click to move them.
6. Press Esc to return to the editor. The map goes back to exactly how it was before the play test.
7. Press Ctrl+S, type a name and press Enter to save your map.

Adding the in-game editor to your scene

Requirements

• An RTS Terrain in the scene with a map (GameObject ▸ RTS Terrain Studio ▸ RTS Terrain).
• A camera. By default the editor uses Camera.main, the camera tagged MainCamera. You can also assign any camera.
• The Resources/RTSTerrainStudio/UI folder of the package. It contains the UI theme and style sheet.

Steps

1. Open your scene and choose GameObject ▸ RTS Terrain Studio ▸ In-Game Editor. This creates an object named RTS In-Game Editor with the RTSRuntimeEditor component. If you right-click an object in the Hierarchy and use the menu there, the new object becomes a child of that object.
2. If the Console warns that there is no RTS Terrain, add one. If it warns that no camera is tagged MainCamera, either tag your camera or assign it to Target Camera.
3. Optionally assign the terrain and camera explicitly and adjust the other settings (see Inspector reference).
4. Press Play. The editor appears, or press F2 to open it if you turned off Start Visible.

What the component creates at runtime

You do not need to build any UI or camera rig yourself. When it is enabled, RTSRuntimeEditor creates:

How the terrain and camera are found

• Terrain: an assigned terrain is used as soon as it is enabled. If the field is empty, the editor uses RTSTerrain.Main, the first RTS Terrain in the scene. While no terrain is found, the editor checks again twice per second and shows the notice No RTS Terrain found.
• Several terrains: if the scene contains more than one RTS Terrain, the Map menu lists them under Edited terrain. Switching to another terrain clears the undo history.
• Camera: if Target Camera is empty, the editor uses Camera.main and keeps looking for it. Until a camera exists, it shows the notice No camera found.

A tour of the interface

The screen is divided into five areas. Every button, field and status item shows a tooltip after you hover over it for a moment, and disabled buttons show one too. If you are not sure what something does, hover over it.