RTS Terrain Studio

Wie eine Karte aufgebaut ist

Wenn du schon mit dem Karteneditor eines klassischen RTS-Spiels gearbeitet hast, werden dir die meisten dieser Konzepte vertraut vorkommen. Eine Karte ist ein Raster aus quadratischen Zellen (standardmäßig 2 m breit). Die Ecken der Zellen sind die Vertices, und die meisten Daten werden pro Vertex oder in hochauflösenden Texturen gespeichert, die die ganze Karte abdecken.

In einer Szene liegt eine Karte auf einem GameObject mit der Komponente RTSTerrain. Der Menübefehl GameObject ▸ RTS Terrain Studio ▸ RTS Terrain fügt ihm außerdem die Komponenten der Subsysteme hinzu (RTSVegetationRenderer, RTSWaterRenderer und RTSDecorManager). Das Terrain liest die Karte aus einer .rtsmap-Datei in deinem Projekt (einem RTSMapAsset). Die Chunk-Meshes, das Gras und das Wasser, die es anzeigt, werden aus dieser Datei erzeugt. Sie werden nie in der Szene gespeichert, deshalb bleiben deine Szenen klein.

Deine ersten fünf Minuten

So siehst du am schnellsten, wie alles zusammenspielt. Außer dem Import des Pakets ist keine Einrichtung nötig.

1. Öffne Tools ▸ RTS Terrain Studio ▸ Validate Project und klicke auf Fix All. Dadurch werden URP, das Renderer Feature für den Nebel des Krieges, die vom Wasser genutzten Kameratexturen und der Farbraum eingerichtet. Ein Bestätigungsdialog erklärt die Änderungen, bevor etwas angepasst wird.
2. Führe Tools ▸ RTS Terrain Studio ▸ Create Demo Content aus. Während Texturen, Modelle, Tilesets, Karten und Szenen erzeugt werden, erscheint ein Fortschrittsbalken. Danach ist die Szene RTS Terrain Studio - Gameplay Demo im Project-Fenster ausgewählt.
3. Doppelklicke auf diese Szene, um sie zu öffnen, und drücke dann auf Play.
4. Wähle deine Einheiten mit der linken Maustaste aus (anklicken oder ein Auswahlrechteck aufziehen) und klicke mit der rechten Maustaste auf den Boden, um sie zu bewegen. Bewege die Kamera mit WASD oder den Pfeiltasten, zoome mit dem Mausrad und drücke F1, um die gesamte Steuerung anzuzeigen.
5. Beende den Play Mode und öffne die Szene RTS Terrain Studio - Editor Playground. Öffne Tools ▸ RTS Terrain Studio ▸ Editor Window, wähle ein Werkzeug und male in der Scene View. Halte Shift gedrückt, um das Gegenteil zu bewirken (zum Beispiel absenken statt anheben). Drücke Ctrl+Z, um einen Schritt rückgängig zu machen.
6. Öffne die Szene RTS Terrain Studio - In-Game Editor Demo und drücke auf Play. Das ist der Editor, den deine Spieler bekommen. Drücke F5, um die Karte mit Einheiten im Spiel zu testen, und F2, um den Editor ein- oder auszublenden.

Wo du anfängst

Funktionen

Jedes der folgenden Bearbeitungswerkzeuge gibt es sowohl im Unity Editor als auch im In-Game-Editor, denn beide verwenden dieselben Werkzeugklassen (Unterklassen von RTSTool). Die Namen in dieser Liste entsprechen denen, die du in der Benutzeroberfläche siehst.

Designentscheidungen auf einen Blick

Hier findest du die häufigsten Fragen zu Terrain-Werkzeugen für RTS-Spiele und wie RTS Terrain Studio sie beantwortet.

Ein erster Blick auf die API

Damit Programmierer einen Eindruck von der API bekommen, folgt hier ein vollständiges Skript. Es fragt beim Terrain ab, was über den Punkt bekannt ist, auf den du klickst, und plant mit dem integrierten Pathfinder einen Pfad dorthin. Es braucht weder Collider noch zusätzliche Komponenten: Hänge es an ein beliebiges GameObject in einer Szene mit einem 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 ist Success, Partial (der nächstgelegene erreichbare Punkt), NoPath oder InvalidStart. Das Kapitel Scripting-Leitfaden erklärt die gesamte API.

Voraussetzungen

Ordnerstruktur

Das Paket liegt in einem einzigen Ordner, standardmäßig Assets/RTSTerrainStudio. Du kannst diesen Ordner verschieben oder umbenennen: Der Editor findet den Stammordner des Pakets über den Speicherort von RTSTerrainStudio.Runtime.asmdef, und die Pfade zu Demo-Inhalten und Dokumentation werden relativ dazu bestimmt.

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)

Lieferumfang

Das Paket besteht aus Quellcode, Shadern und diesem Handbuch. Alles Visuelle (Texturen, Modelle, Tilesets, Karten und Szenen) erzeugt ein Skript auf deinem Rechner. Das hält den Download klein, und die Inhalte sind genau wie der Code lizenziert.

Demokarten

Alle drei Karten verwenden 2 m große Zellen, eine Stufenhöhe von 2 m und das Tileset Summer.

Karte	Größe	Symmetrie	Beschreibung
Two Rivers (1v1).rtsmap	128 × 128 Zellen	Rotate 2	Zwei Spieler, zwei Flüsse. Überall führen flache Furten durch die Flüsse, und der See in der Mitte ist tief. Rampen führen hinauf zu bewaldeten Plateaus mit Ruinen und verlassenen Lagern.
Four Kingdoms (4p).rtsmap	192 × 192 Zellen	Rotate 4	Vier Königreiche, jedes auf seinem eigenen Hochland. Rampen führen hinab in das gemeinsame Tiefland, und in der Mitte liegt verseuchter Boden mit den Ruinen eines alten Tempels.
Sandbox.rtsmap	96 × 96 Zellen	None	Eine kleine, überwiegend flache Karte zum Ausprobieren der Werkzeuge.

Icons

Alle Icons im Editorfenster, in den Inspectors und im In-Game-Editor zeichnet RTSIcons prozedural. Dadurch bleiben sie in jeder Größe scharf und funktionieren in Builds ohne Textur-Assets.

Installation und Einrichtung

Die Demoszenen öffnen

Die Demoszenen liegen in RTSTerrainStudio/Samples/Scenes. Öffne eine per Doppelklick im Project-Fenster, oder wähle sie in Schritt 3 des Welcome-Fensters aus und klicke auf Open.

Deine erste Karte

Eine Karte befindet sich auf einem GameObject RTS Terrain in deiner Szene und wird in einer .rtsmap-Datei in deinem Projekt gespeichert. Die Szene verweist nur auf die Datei; deine Änderungen werden in der Datei gespeichert. Beginne mit einer neuen Szene, damit du frei experimentieren kannst:

1. Wähle File ▸ New Scene und eine URP-Szenenvorlage (zum Beispiel Basic (URP)).
2. Speichere die Szene sofort mit Ctrl+S, zum Beispiel als Assets/MyMaps/FirstMap.unity. Neue Kartendateien werden neben der gespeicherten Szene angelegt. So bleiben Karte und Szene zusammen.

Das Editorfenster öffnen

Öffne Tools ▸ RTS Terrain Studio ▸ Editor Window (der Assistent und das Welcome-Fenster können es für dich öffnen, und im Inspector von RTS Terrain gibt es eine Schaltfläche Open RTS Terrain Studio). Docke es neben dem Inspector an, damit du gleichzeitig die Scene View siehst.

Bereich	Anzeige
Kopfzeile	Terrain-Auswahl, Kartenname (ein Punkt steht für nicht gespeicherte Änderungen), Save, Save As…, Open…, Reload, Undo / Redo mit dem Namen des Schritts, eine Hilfe-Schaltfläche und der Schalter Editing On / Editing Off.
Tab-Leiste	Acht Werkzeugkategorien (Height, Cliffs, Paint, Vegetation, Decor, Water, Pathing, Markers), danach Map und Settings. Ein Punkt markiert die Kategorie des aktiven Werkzeugs.
Werkzeugseite	Große Werkzeugschaltflächen, ein Panel, das das aktive Werkzeug mit seinem Live-Status beschreibt, die Panels Brush und Symmetry sowie die eigenen Einstellungen und Paletten des Werkzeugs (Schichten, Klippenstufen, Spieler, Bäume, Dekor).
Statusleiste	Zelle unter dem Cursor, Klippenstufe, Höhe und Pathing unter der Maus sowie der Undo-Speicher.

Die acht Kategorien und ihre Werkzeuge:

Taste	Kategorie	Werkzeuge
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

Jedes Werkzeug wird in einem eigenen Kapitel ausführlich beschrieben (zum Beispiel Höhenwerkzeuge und Klippenwerkzeuge); das Fenster selbst wird unter Editorfenster beschrieben.

Dein erster Spieltest

Du kannst deine Karte auf zwei Arten spielen: mit dem Demo Game im Play Mode oder im laufenden Spiel mit dem In-Game-Editor und seiner Schaltfläche 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");
        }
    }
}

10-Minuten-Tutorial: deine erste 1v1-Karte

In diesem Tutorial baust du eine kleine, faire Karte für zwei Spieler: Jeder Spieler erhält eine Basis auf einem Plateau mit Rampe, ein Fluss trennt die beiden Hälften, und Wälder rahmen die Karte ein. Weil du mit Symmetrie malst, sind beide Seiten identisch, und du musst nur eine Hälfte bauen.

Wie geht es weiter?

• Editorfenster: alle Tabs, Panels und Einstellungen im Detail, einschließlich des Tabs Map (Größenänderung, Kartengenerator, Import und Export von Heightmaps, Minikarte, Umgebung).
• Die Werkzeugkapitel, eines pro Kategorie: Height, Cliffs, Paint, Vegetation, Decor, Water, Pathing, Markers.
• In-Game-Editor: den Editor mit deinem Spiel ausliefern, damit Spieler Karten bauen können.
• Scripting: Höhen, Klippenstufen und Pathing aus Code abfragen, Karten zur Laufzeit laden, auf Bearbeitungen reagieren.
• Integrationen: Multiplayer mit Mirror, Wegfindung mit dem A* Pathfinding Project oder Unity NavMesh.
• Fehlerbehebung: pinke Materialien, flach wirkendes Wasser, Versatz beim Malen und andere häufige Probleme.

Der Project Validator

Öffne Tools ▸ RTS Terrain Studio ▸ Validate Project oder klicke im Welcome-Fenster auf Validate. Die Prüfungen starten, sobald sich das Fenster öffnet. Sie sind in fünf Kategorien unterteilt:

Jedes Ergebnis hat einen von vier Statuswerten:

Fix All wendet alle verfügbaren Korrekturen an. Zuvor listet ein Dialog alle Änderungen auf; geändert wird erst, wenn du auf Apply Fixes klickst. Korrekturen, die URP voraussetzen (die Kameratexturen und das Renderer Feature für den Nebel des Krieges), laufen automatisch, sobald die Pipeline zugewiesen ist. So genügt ein einziger Klick, um ein frisches Projekt einzurichten. Run Again wiederholt die Prüfungen. Die vollständige Liste der Prüfungen mit ihren Korrektur-Schaltflächen findest du unter Das Projekt validieren.

Prüfungen per Code ausführen

RTSProjectValidator.RunChecks() liefert die Ergebnisse, ohne etwas zu ändern, und RTSProjectValidator.FixAll() wendet die Korrekturen an. Du kannst beide in einem Build-Skript oder einem Continuous-Integration-Job verwenden. Das Beispiel muss in einem Ordner Editor liegen.

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

Alle Shader des Pakets sind für URP geschrieben. Ohne URP werden Terrain, Wasser und Vegetation pink oder gar nicht dargestellt. Die Korrektur Use URP verwendet ein vorhandenes URP-Asset des Projekts (oder erstellt Assets/Settings/RTS URP.asset mit einem Renderer) und weist es als Standard-Render-Pipeline sowie jeder Qualitätsstufe zu, die eine andere Pipeline verwendet. So machst du dasselbe von Hand:

1. Wenn das Projekt noch kein URP-Asset hat, erstelle eines im Project-Fenster über Create ▸ Rendering ▸ URP Asset (with Universal Renderer).
2. Weise es unter Edit ▸ Project Settings ▸ Graphics als Default Render Pipeline zu.
3. Öffne Edit ▸ Project Settings ▸ Quality. Prüfe bei jeder Qualitätsstufe mit einem Override für Render Pipeline Asset, dass es sich ebenfalls um ein URP-Asset handelt.

Depth Texture und Opaque Texture

Wasser nutzt die Tiefentextur der Kamera, damit sich Tiefenfarbe, Schaum und der weiche Übergang am Ufer an Objekte anpassen, die im Wasser stehen. Die Opaque-Textur nutzt es für die Lichtbrechung. Ohne sie wirkt das Wasser schlichter. Wähle jedes URP-Asset aus, das deine Qualitätsstufen verwenden, und aktiviere in seinem Abschnitt Rendering die Optionen Depth Texture und Opaque Texture, oder klicke im Validator auf Enable Both.

Das Renderer Feature für den Nebel des Krieges

Das Renderer Feature RTS Fog Of War (RTSFogOfWarRendererFeature) zeichnet den Nebel über alles auf dem Bildschirm, auch über Einheiten und Props mit deinen eigenen Materialien. Ohne das Feature zeigen nur die Shader des Pakets den Nebel. Add Feature fügt es dem Standard-Renderer jedes verwendeten URP-Assets hinzu. Um es von Hand hinzuzufügen, wähle das Asset Universal Renderer Data aus, klicke auf Add Renderer Feature und wähle RTS Fog Of War. Details findest du unter Rendering: Renderer Feature und Shader-Fallback.

Farbraum

Das Paket ist für den Farbraum Linear ausgelegt, den Standard von URP. Im Farbraum Gamma wirken Farben, Beleuchtung und Wasser im Vergleich zu den Screenshots ausgewaschen. Stelle Edit ▸ Project Settings ▸ Player ▸ Other Settings ▸ Color Space auf Linear, oder klicke im Validator auf Switch to Linear.

Benötigte Pakete

Die Laufzeit-Assembly verwendet Burst (com.unity.burst), Collections (com.unity.collections) und Mathematics (com.unity.mathematics) für ihre Jobs und ihr Datenmodell. Solange eines davon fehlt, kompilieren die Skripte des Pakets nicht. Installiere sie über Window ▸ Package Manager ▸ Unity Registry, oder klicke im Validator auf Install. Der Validator fügt dann alle fehlenden Pakete mit einer einzigen Anfrage an den Package Manager hinzu. Die getesteten Versionen stehen unter Benötigte Pakete.

Eingabeverarbeitung

Alle Eingaben zur Laufzeit (für den In-Game-Editor, die Beispielkamera und die Beispieleinheiten) laufen über die statische Klasse RTSInput. Wenn das Paket Input System (com.unity.inputsystem) installiert ist, wird die Laufzeit-Assembly mit dem Define-Symbol RTS_INPUT_SYSTEM kompiliert und nutzt das Input System. Andernfalls oder wenn das Projekt nur den alten Input Manager verwendet, fällt RTSInput auf die alte API UnityEngine.Input zurück.

Die Einstellung findest du unter Edit ▸ Project Settings ▸ Player ▸ Other Settings ▸ Active Input Handling. Wenn du sie änderst, fordert Unity dich auf, den Editor neu zu starten. Die Prüfung Input handling ändert die Einstellung nie von sich aus, weil sie von deinem Spiel abhängt. Siehe auch Eingabeverarbeitung in den Voraussetzungen.

Shader und Inhalte

• Package shaders compile. Wenn ein Shader des Pakets Kompilierfehler hat (betroffene Objekte werden pink dargestellt), importiert Reimport ihn neu. Das hilft, wenn die Shader importiert wurden, bevor URP fertig geladen war. Fehlen benötigte Shader vollständig, importiere das Paket erneut aus dem Asset Store. Siehe Fehlerbehebung.
• Shaders included in builds. Siehe Einen Build erstellen.
• Tileset texture arrays built. Tilesets, deren gebaute Arrays fehlen oder veraltet sind, funktionieren trotzdem. Bis die Arrays neu gebaut sind, baut der Editor beim Laden der Karte aber unkomprimierte Arrays. Das kostet Speicher und Ladezeit. Build Arrays baut sie für jedes veraltete Tileset. Bei Player-Builds werden veraltete Arrays automatisch neu gebaut; Tilesets, die nie gebaut wurden, verwenden auch in Player-Builds unkomprimierte Arrays. Siehe Textur-Arrays und Textur-Arrays in Player-Builds.
• GPU instancing on instanced prototypes. Bei Materialien von instanzierten Bäumen, Details im Modus Mesh und instanziertem Dekor sollte Enable GPU Instancing aktiviert sein. Andernfalls werden sie über temporäre Kopien gezeichnet, und ihre Instancing-Varianten werden unter Umständen aus Player-Builds entfernt. Enable Instancing aktiviert die Option bei jedem aufgelisteten Material, das sich bearbeiten lässt. Materialien innerhalb eines Modells oder eines Pakets sind schreibgeschützt: Extrahiere sie zuerst. Siehe GPU-Instancing.
• Terrains have a tileset. Ein Terrain ohne Tileset erscheint in einer neutralen Platzhalterdarstellung. Die Korrektur weist jedem Terrain ohne Tileset ein Tileset des Projekts zu (lässt sich rückgängig machen). Siehe Tilesets.

Kartendateien für Terrains in Szenen

Ein RTS Terrain speichert seine Karte in einem .rtsmap-Asset (Feld Map Asset). Ein Terrain ohne ein solches Asset hält seine Karte nur im Arbeitsspeicher, und deine Bearbeitungen gehen verloren, wenn die Szene geschlossen wird. Die Prüfung Terrains save to a map file listet diese Terrains auf. Create Map Files speichert die aktuelle Karte jedes aufgelisteten Terrains in einer neuen .rtsmap-Datei im Ordner seiner Szene (oder in Assets/Maps, wenn die Szene noch nicht gespeichert ist) und weist sie dem Terrain zu.

Terrains, die mit dem New Map Wizard oder den Demo-Inhalten erstellt wurden, haben bereits eine Kartendatei. Wie Karten-Assets, Save und Save As funktionieren, erfährst du unter Karten-Assets und Kartendateien.

Einen Build erstellen

Unity nimmt Shader nur dann in einen Player-Build auf, wenn ein Material im Build sie verwendet. RTS Terrain Studio erzeugt die Materialien für Terrain, Wasser und Nebel des Krieges zur Laufzeit per Code. Deshalb werden die Shader vom Asset Resources/RTSTerrainStudio/RTSShaderReferences.asset im Paketordner referenziert. Das Asset referenziert außerdem das Material DecorPlaceholder, das die Instancing-Varianten von URP Lit im Build hält. Das Asset wird nach jedem Neuladen der Skripte, bei jedem Import von Shadern und vor jedem Player-Build automatisch geprüft und aktualisiert. Wenn die Prüfung Shaders included in builds rot ist, klicke auf Update.

Gehe vor dem Build diese Liste durch:

1. Führe Tools ▸ RTS Terrain Studio ▸ Validate Project aus und behebe alle Fehler und Warnungen.
2. Prüfe, ob jede Qualitätsstufe deiner Zielplattform ein URP-Asset mit Depth Texture und Opaque Texture verwendet und ob dessen Renderer das Feature RTS Fog Of War hat, falls du den Nebel des Krieges nutzt.
3. Baue die Textur-Arrays deiner Tilesets einmal (Build Arrays im Validator oder Build Texture Arrays im Tileset-Inspector), damit das Terrain sie nicht beim Laden unkomprimiert baut. Veraltete Arrays werden vor jedem Player-Build automatisch neu gebaut (siehe unten).
4. Wenn deine Karten atmosphärischen Nebel nutzen, stelle sicher, dass die Prüfung Fog kept in player builds OK ist (siehe Nebel in Player-Builds).
5. Validiere deine Karten im Tab Map (siehe Kartenvalidierung).
6. Füge deine Szenen der Szenenliste deines Build-Profils hinzu. Karten, die einem RTS Terrain in einer Szene zugewiesen sind, werden wie jedes andere referenzierte Asset in den Build aufgenommen.
7. Wenn du den In-Game-Editor mit auslieferst, lies Den In-Game-Editor mit dem Spiel ausliefern. Karten, die Spieler zur Laufzeit speichern, landen im Ordner Maps in RTSMapSerializer.StorageRoot (Application.persistentDataPath, in Web-Builds der Browserspeicher); siehe Kartendateien zur Laufzeit.
8. Wenn du die Einstellung Managed Stripping Level über Minimal anhebst und eigene Bearbeitungswerkzeuge geschrieben hast, lies Code-Stripping und eigene Werkzeuge.
9. Lies für einen Web-Build außerdem Web-Builds (WebGL).

Textur-Arrays in Player-Builds

Ein Player-Build verwendet die gebauten Textur-Arrays eines Tilesets so, wie sie sind, denn nur der Editor kann sie mit den Quelltexturen vergleichen. Damit ein Build nie veraltete Bodentexturen ausliefert, wird jedes Tileset, dessen Arrays schon einmal gebaut wurden, direkt vor dem Start eines Player-Builds geprüft:

• Arrays, die nicht mehr zu den Texturen, der Auflösung oder der Komprimierung passen oder die für eine andere Plattform oder Texturkomprimierung gebaut wurden, werden mit normaler Komprimierungsqualität neu gebaut. Währenddessen wird ein Fortschrittsbalken angezeigt.
• Tilesets, die nie gebaut wurden, bleiben unverändert. Player-Builds bauen für sie beim Laden einer Karte unkomprimierte Arrays.
• Wenn ein Neubau abgebrochen wird oder fehlschlägt und sich die Texturen oder Einstellungen geändert haben, bietet ein Dialog Try Again, Cancel Build und Build Anyway an. Arrays, die nur ein anderes Format verwenden, zeigen trotzdem die richtigen Texturen und erzeugen deshalb nur eine Warnung im Log.
• Ein Build im Batch-Modus bricht in diesem Fall ab. Füge der Befehlszeile -rtsAllowOutdatedTextureArrays hinzu, um trotzdem zu bauen; dann wird pro Tileset eine Warnung ausgegeben.
• Ein Editor ohne Grafikgerät (-nographics, üblich auf Build-Servern) kann keine Arrays bauen. Der Build läuft dann mit einer Warnung pro veraltetem Tileset weiter, und Player-Builds verwenden die Arrays so, wie sie zuletzt gebaut wurden. Baue die Arrays vor einem solchen Build im Editor.
• Arrays werden nur für die aktive Build-Plattform neu gebaut. Wenn du für eine andere Plattform baust, schreibt der Build stattdessen eine Warnung ins Log: Wechsle vorher zu dieser Plattform.
• Asset Bundles und Addressables-Inhalte, die du separat baust, durchlaufen diese Prüfung nicht. Baue die Arrays vorher.

Gebaute Arrays werden lesbar im Tileset-Asset gespeichert. Player-Builds geben diese CPU-Kopie frei, sobald die Arrays zum ersten Mal verwendet werden. Das spart etwa 14 MB pro Tileset bei 512 px und etwa 56 MB bei 1024 px.

Nebel in Player-Builds

RTSEnvironment schaltet den in einer Karte gespeicherten atmosphärischen Nebel ein, während das Spiel läuft. Unity entfernt die Shader-Varianten von Nebelmodi, die es für unbenutzt hält. Steht Project Settings ▸ Graphics ▸ Shader Stripping ▸ Fog Modes auf Automatic, behält Unity nur den Nebel von Build-Szenen, die mit eingeschaltetem Nebel gespeichert sind. RTS Environment stellt vor jedem Speichern den eigenen Nebel der Szene wieder her. Sein Nebel zählt deshalb nicht, und Karten mit Nebel würden im Build keinen Nebel zeigen.

Die Prüfung Fog kept in player builds liest die Build-Szenen des aktiven Build-Profils und die geöffneten Szenen und listet die Nebelmodi auf, die RTS Environment dort verwendet. Keep Fog Modes (auch Teil von Fix All) stellt Fog Modes auf Custom und behält genau diese Modi, dazu alle, die bereits behalten wurden. Jeder behaltene Modus fügt dem Build Shader-Varianten hinzu, deshalb werden nicht verwendete Modi nicht hinzugefügt. Wenn das aktive Build-Profil die Graphics-Einstellungen überschreibt, prüfe auch dort die Fog Modes.

Web-Builds (WebGL)

RTS Terrain Studio läuft im Webbrowser: Terrain, Vegetation, Wasser, Dekor, Nebel des Krieges, der In-Game-Editor und die Beispiele. Ein Browser funktioniert allerdings anders als ein Desktop-System: Es gibt keinen Ordner, den der Spieler öffnen kann, manche Tasten gehören dem Browser, der gesamte Code läuft auf einem einzigen Thread, und das ganze Spiel teilt sich einen Speicher-Heap begrenzter Größe. Dieser Abschnitt erklärt, wie das Paket damit umgeht und wie du einen Web-Build erstellst, testest und veröffentlichst.

Kurz zusammengefasst:

1. Öffne File ▸ Build Profiles, wähle Web und klicke auf Switch Platform (oder mache dein Web-Build-Profil zum aktiven Profil).
2. Führe Tools ▸ RTS Terrain Studio ▸ Validate Project aus und klicke auf Fix All. Wenn Web aktiv ist, installiert der Validator außerdem das Vollfenster-Template und prüft die Qualitätsstufen von Web-Builds.
3. Wenn deine Karten atmosphärischen Nebel nutzen, prüfe, ob Fog kept in player builds OK ist.
4. Klicke auf Build And Run. Unity baut das Spiel und öffnet es in deinem Browser.

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

Das Kartenmodell

Alle Kartendaten liegen in einem einzigen Objekt der Klasse MapData (Namespace RTSTerrainStudio). Eine Komponente RTSTerrain besitzt genau ein MapData-Objekt (terrain.Map), stellt es als Chunk-Meshes dar, hält die daraus abgeleitete Pathing-Karte aktuell und beantwortet Abfragen wie „Wie hoch ist der Boden hier?“.

Zellen und Vertices

Die Karte ist ein Raster aus Width × Height Zellen. Jede Zelle hat an ihren vier Ecken je einen Vertex, und benachbarte Zellen teilen sich ihre Ecken. Eine Karte mit 4 × 2 Zellen hat deshalb 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-Schichten (Feinhöhe, Klippenstufe, Flags, Klippentyp, Wasserhöhe) haben (Width + 1) × (Height + 1) Einträge, Zeile für Zeile gespeichert. Verwende map.VertexIndex(x, z).
• Die Zellgröße (map.CellSize, standardmäßig 2 m) ist die Weltgröße einer Zelle. Eine Karte mit 128 × 128 Zellen à 2 m deckt 256 × 256 m ab (map.WorldSize).
• Eine Position gehört zur Zelle floor(localXZ / CellSize); map.LocalToCell(localXZ) berechnet das und begrenzt das Ergebnis auf die Karte.
• Zum Rendern werden die Zellen zu Chunks zusammengefasst (16, 32 oder 64 Zellen pro Seite, Einstellung Chunk Size der Komponente RTSTerrain, standardmäßig 32). Nur Chunks, die von einer Bearbeitung betroffen sind, werden neu aufgebaut. Die Chunk-Größe ändert die Kartendaten nicht.

Kartenabmessungen

Die Abmessungen werden beim Anlegen einer Karte festgelegt (im New Map Wizard, im In-Game-Dialog New Map oder über MapCreationSettings im Code). Werte außerhalb des gültigen Bereichs korrigiert MapCreationSettings.Validate().

Was eine Karte enthält

Für jede Datenart gibt es ein passendes Flag im Enum MapLayers. Die Flags werden für Änderungsbenachrichtigungen, die Undo-Aufzeichnung und die Serialisierung verwendet.

Zwei kombinierte Flags sind praktisch: MapLayers.Geometry (Höhen, Stufen, Vertex-Flags, Klippentypen) und MapLayers.PathingInputs (alles, was die Pathing-Karte beeinflusst). MapLayers.All umfasst alles.

Die Pathing-Karte (terrain.Pathing, Klasse PathingMap) besteht aus abgeleiteten Daten: Sie wird aus den obigen Schichten berechnet und nie gespeichert. Siehe Pathing-Karte.

Klippenstufen, Feinhöhen und Klippentypen

Klassisches RTS-Terrain kennt zwei Arten von Höhe: große, diskrete Stufen (Klippen) und kleine, sanfte Variationen (Hügel). RTS Terrain Studio speichert beide getrennt für jeden Vertex.

Klippenstufen

• Jeder Vertex hat eine Klippenstufe von 0 bis 15 (MapData.MaxCliffLevel = 15).
• Eine Stufe ist CliffLevelHeight Meter hoch (standardmäßig 2 m).
• Neue Karten beginnen auf Stufe 2. So bleiben zwei Stufen unter dem Boden für Seen, Flüsse und Schluchten und dreizehn darüber für Plateaus.
• Bearbeite die Stufen mit den Klippenwerkzeugen: Raise / Lower Level, Set Level, Ramp, Cliff Type und Clean Cliffs.
• Der Nebel des Krieges nutzt die Klippenstufen für die Sichtlinie: Einheiten sehen ihre eigene Stufe und alles darunter; höher gelegener Boden versperrt ihnen die Sicht.

Feinhöhen

Zusätzlich zur Stufe hat jeder Vertex eine Feinhöhe in Metern (Heights), positiv oder negativ. Die Höhenwerkzeuge (Raise / Lower, Smooth, Flatten, Set Height, Noise, Terrace, Erode) ändern nur die Feinhöhe. So kannst du Hügel auf einem Plateau bauen, ohne dass daraus Klippen werden. Die Bodenhöhe eines Vertex ergibt sich so:

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

Beispiel: Stufe 3 bei einer Stufenhöhe von 2 m und einer Feinhöhe von 0.4 m ergibt einen Vertex, der 6.4 m über dem Kartenursprung liegt. map.GetVertexHeight(x, z) und map.GetVertexPosition(x, z) berechnen das für dich.

Klippentypen

Ein Tileset kann bis zu 4 Klippenschichten haben (zum Beispiel „Rock“ und „Grassy Cliff“). Jeder Vertex speichert, welche davon verwendet wird (CliffTypes, 0–3, gemalt mit dem Werkzeug Cliff Type). Eine Klippenwand verwendet den Klippentyp der höchsten Ecke ihrer Zelle. Hat ein Klippentyp-Index keine Schicht im Tileset, greift die Wand auf Klippenschicht 0 zurück.

Wie die Oberfläche entsteht (die Referenzoberfläche)

Das Struct MapGeometryView definiert die einzig gültige Oberfläche des Terrains. Die Chunk-Meshes, die Gameplay-Abfragen (GetHeight, Raycast, …), die Pathing-Karte und der Nebel des Krieges folgen alle denselben Regeln. Was du siehst, ist also genau das, worauf die Einheiten laufen. Jede Zelle wird anhand ihrer vier Ecken eingeordnet:

Abgerundete Konturen. Innerhalb einer Klippenzelle wird für jede Stufenschwelle t der Indikator „Eckstufe ≥ t“ (1 oder 0) bilinear über die Zelle interpoliert. Ein Punkt gehört zur höchsten Stufe, deren interpolierter Indikator mindestens 0.5 beträgt (MapGeometryView.LevelAt). Das ist eine Marching-Squares-Regel: Eine einzelne angehobene Ecke ergibt einen Viertelkreis statt einer Diagonale, und lange Klippenlinien bleiben gerade. Die Wand selbst verläuft an der Kontur senkrecht. Die Feinhöhen werden immer bilinear interpoliert und obendrauf addiert, auch innerhalb von Klippenzellen.

Das Aussehen der gerenderten Wände stellst du an der Komponente RTSTerrain ein (Settings):

Die Geometrieansicht erhältst du mit map.GetGeometryView(). Sie ist ein Struct aus nativen Arrays, daher kannst du sie auch an Burst-Jobs übergeben. Alle Member erwarten kartenlokale Positionen:

Rampen

Über eine Rampe gelangen Einheiten von einer Klippenstufe zur nächsten. Die Regel ist einfach:

• Das Flag heißt VertexFlags.Ramp und wird pro Vertex gesetzt. Das Werkzeug Ramp (ID cliff.ramp) malt es; halte Shift gedrückt, um es zu entfernen.
• Eine Rampenzelle ist ein weicher, bilinearer Hang zwischen ihren Eckhöhen (Stufe plus Feinhöhe).
• Rampen funktionieren am besten über genau eine Stufe. Steilere Rampen sind erlaubt, aber die Statusleiste warnt vor Rampenzellen, die mehr als eine Stufe überspannen.
• Pathing: Bei einer gültigen Rampe über eine Stufe wird die Begehbarkeit nur anhand der Neigung ihrer Feinhöhen geprüft (der Stufenanstieg, den sie überbrückt, macht sie nicht „zu steil“). Rampen sind nie bebaubar.
• GetCliffLevel liefert auf einer Rampe die interpolierte Stufe, gerundet: auf der unteren Hälfte die untere Stufe, auf der oberen Hälfte die obere.

1. Hebe mit Raise / Lower Level ein Plateau um eine Stufe an.
2. Wähle das Werkzeug Ramp und male dort über die Klippenkante, wo die Rampe entstehen soll. Achte darauf, dass der Pinsel mindestens die Vertices auf beiden Seiten der Wand abdeckt, damit jede Ecke der dazwischenliegenden Zellen markiert wird.
3. Die Wand verschwindet, und ein Hang entsteht. Verbreitere die Rampe, indem du weitere Vertices entlang der Kante bemalst.

Bodenschichten und Splatmaps

Bodentexturen werden in Splatmaps gemalt: vier RGBA-Texturen (MapData.SplatMapCount = 4) mit SplatWidth × SplatHeight Texeln. Jeder der 16 Kanäle enthält die Gewichtung einer Bodenschicht des Tilesets:

• Schicht i liegt in Splatmap i / 4, Kanal i % 4. Deshalb hat ein Tileset genau 16 Bodenschichten: 4 Splatmaps × 4 Kanäle.
• Die Gewichtungen eines Texels ergeben über alle 16 Kanäle zusammen immer 255. Alle Malwerkzeuge halten diese Invariante ein; Code, der Splat-Daten schreibt, muss sie ebenfalls einhalten.
• Die Splat-Auflösung ist die Anzahl der Texel pro Zellseite (standardmäßig 4). Bei Zellen von 2 m ergibt das alle 0.5 m ein Texel.
• Die Mitte des Texels (x, z) liegt in kartenlokalen XZ-Koordinaten bei ((x + 0.5), (z + 0.5)) × CellSize / SplatResolution. Dieselbe Formel gilt auch für Detail- und Pathing-Texel, jeweils mit ihrer eigenen Auflösung.
• Hilfsmethoden: map.SplatIndex(x, z), map.GetSplatWeight(texelIndex, layer), map.GetDominantLayer(texelIndex), MapData.GetChannel / SetChannel und 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));
    }
}

Wasser

• Ein Vertex liegt unter Wasser, wenn er das Flag VertexFlags.Water trägt. Die Höhe seiner Wasseroberfläche (kartenlokales Y, Meter) wird in WaterHeights gespeichert; der Wert ist nur dort aussagekräftig, wo das Flag gesetzt ist.
• Ein Punkt ist nass, wenn die bilinear interpolierte Abdeckung aus den Wasser-Flags der vier Ecken seiner Zelle mindestens 0.5 beträgt. Ecken ohne Wasser in einer nassen Zelle verwenden die höchste Wasserhöhe der Zelle, damit Uferlinien waagerecht bleiben.
• Wassertiefe = Wasseroberfläche − Bodenhöhe. Die Tiefe bestimmt das Pathing: Wasser, das tiefer ist als der Wert Shallow Depth Limit des Tilesets (standardmäßig 0.9 m), ist Tiefwasser (nicht begehbar); flacheres Wasser ist Flachwasser (begehbar, standardmäßig nicht bebaubar).
• Die Wasserwerkzeuge sind Paint Water, Erase Water und Flood Fill. Wasseränderungen melden nur MapLayers.Water, deshalb werden beim Malen von Wasser keine Terrain-Chunks neu aufgebaut.
• Abfragen: terrain.IsWater(world, out depth) und terrain.TryGetWaterHeight(world, out waterWorldY).

Das Aussehen des Wassers (Farben, Wellen, Schaum) stammt aus dem Wasserprofil des Tilesets; siehe Wasserprofil.

Detaildichte (Gras und Kleinpflanzen)

• Details sind keine einzelnen Objekte. Jeder Detail-Prototyp, der auf der Karte verwendet wird, hat genau einen DetailLayer in map.DetailLayers: ein Byte pro Detail-Texel (DetailWidth × DetailHeight, standardmäßig 2 Texel pro Zellseite).
• Eine Dichte von 0 bedeutet leer, 255 bedeutet Max Density Instanzen pro Texel (ein Feld des Detail-Prototyps, standardmäßig 6). Jedes Texel erzeugt density / 255 × maxDensity Instanzen. Der Renderer verteilt sie deterministisch, sodass dieselbe Karte immer gleich aussieht.
• Schichten werden der Vegetationsbibliothek über die prototypeId zugeordnet. map.GetOrAddDetailLayer(id) legt bei Bedarf eine Schicht an; map.FindDetailLayer(id) gibt null zurück, wenn der Prototyp nicht verwendet wird.
• Male Details mit Paint Details und entferne sie mit Erase Details.

Baum- und Dekorinstanzen

Bäume (TreeInstanceData) und Dekorobjekte (DecorInstanceData) werden als einfache Listen gespeichert. Statt eines Prototypnamens speichert jede Instanz einen kleinen Palettenindex, der auf eine Liste von Bibliotheks-IDs in der Karte verweist:

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

• Mit map.GetOrAddTreePrototype(id) / map.GetOrAddDecorPrototype(id) erhältst du den Palettenindex einer Bibliotheks-ID (fehlt sie, wird sie hinzugefügt).
• Da Karten Prototypen über ihre ID referenzieren, kannst du eine Bibliothek gefahrlos umbenennen, umsortieren oder erweitern. Fehlt ein Prototyp in der Bibliothek, überspringt ihn der Vegetation Renderer, und der Decor Manager zeigt ihn als magentafarbenen Platzhalterwürfel an; fügst du einen Prototyp mit derselben ID hinzu, ist er wieder da. Pathing: Bäume mit fehlendem Prototyp werden nicht gezeichnet, blockieren aber weiterhin einen Kreis mit dem Radius PathingMapBuilder.DefaultTreeFootprintRadius (0.8 m) × Skalierung. Dekorplatzhalter tragen erst dann eine Grundfläche in die Pathing-Karte ein, wenn der Prototyp wieder vorhanden ist.
• Jede Instanz hat innerhalb der Karte eine eindeutige, stabile id. Neue IDs erhältst du mit map.AllocateInstanceId().
• Positionen sind kartenlokal. Für Drehungen gilt überall dieselbe Konvention: Winkel in Grad, von oben gesehen im Uhrzeigersinn, 0 = +Z, 90 = +X (wie Unitys Y-Rotation).

Die Konvention für position.y

Kopiere den yOffset des Prototyps niemals in position.y; er wird beim Rendern addiert. DecorMath.ComputeLocalPosition und DecorMath.ToStoredHeight rechnen zwischen gespeicherten und dargestellten Positionen um.

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-Karte

Die Pathing-Karte beantwortet die Frage: „Kann eine Einheit hier laufen, kann hier ein Gebäude stehen?“ Sie ist ein Raster aus Pathing-Zellen (PathingResolution pro Seite einer Kartenzelle, standardmäßig 2, also 1 m große Pathing-Zellen bei einer Karte mit 2 m großen Zellen) mit je einem PathingFlags-Byte. Sie wird automatisch abgeleitet und inkrementell neu aufgebaut, sobald sich eine Eingabe ändert (Geometrie, Wasser, Bodenschichten, Bäume, Dekor, Overrides). Sie selbst wird nie gespeichert, sondern nur die manuellen Overrides.

Wie die Flags abgeleitet werden

1. Terrain: Klippenwände (samt dem Klippenabstand Cliff Margin) setzen Cliff; Neigungen über Max Walkable Slope (standardmäßig 42°) setzen Steep; Wasser setzt je nach Tiefe ShallowWater oder DeepWater; Flyable wird überall gesetzt; Buildable = begehbar, Neigung ≤ Max Buildable Slope (standardmäßig 18°) und trocken (oder Flachwasser, wenn Shallow Water Buildable aktiviert ist). Danach wird der Pathing Effect der dominanten Bodenschicht angewendet (zum Beispiel „Unbuildable“ auf rauem Fels).
2. Grundflächen: Bäume blockieren einen Kreis (Footprint Radius × Baumskalierung × Tree Footprint Scale); Dekor wendet seinen Footprint Effect innerhalb eines Kreises oder eines gedrehten Rechtecks an, es sei denn, die Instanz hat DecorFlags.IgnorePathing.
3. Manuelle Overrides, die mit Paint Pathing / Clear Pathing gemalt wurden, werden zuletzt angewendet.

Die Regeleinstellungen befinden sich in der Komponente RTSTerrain (RTSPathingSettings, Eigenschaft terrain.PathingSettings).

Dieselben PathingOverride-Flags werden für die Pathing-Effekte von Bodenschichten, die Grundflächeneffekte von Dekor und gemalte Overrides verwendet. Frage das Ergebnis mit terrain.GetPathing(world), terrain.IsWalkable(world) und terrain.IsBuildable(world) ab, oder lies terrain.Pathing.Flags direkt aus.

Regionen, Startpositionen und Marker

Es handelt sich um schlanke Objekte für deine Spiellogik. Im Spiel werden sie nicht gerendert; die Editoren zeichnen sie als Gizmos.

Die Werkzeuge speichern für Startpositionen und Marker position.y = 0 und behandeln den Wert wie bei Bäumen als Versatz über dem Boden.

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

Karteninfo und Umgebung

EnvironmentSettings speichert die Beleuchtung einer Karte. Eine RTSEnvironment-Komponente (GameObject ▸ RTS Terrain Studio ▸ Environment) wendet sie auf die Szene an; ohne diese Komponente werden die Werte zwar gespeichert, aber nicht verwendet.

Änderungsbenachrichtigungen

Wenn du MapData per Code änderst, teile dem Terrain mit, was sich wo geändert hat – angegeben in Zellen:

• terrain.NotifyChanged(MapLayers layers, RectInt cellRect) löst MapChanged sofort aus und stellt den Neuaufbau in die Warteschlange.
• terrain.NotifyChangedAll(layers) markiert die ganze Karte (nach Generatoren oder Importen).
• Ausstehende Änderungen werden in LateUpdate verarbeitet (außerhalb des Play Mode auch bei jedem Editor-Tick) oder sofort durch einen Aufruf von terrain.ProcessPendingChanges(). Danach wird ChangesProcessed ausgelöst: Meshes, Texturen und Pathing sind dann auf dem neuesten Stand.
• Ein Vertex berührt bis zu vier Zellen. Ein Vertex-Rechteck rechnest du mit BrushUtility.VertexRectToCellRect(map, vertexRect) in Zellen um, ein Texel-Rechteck mit 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);
    }
}

Koordinaten und mehrere Terrains

Alle Kartendaten werden in kartenlokalen Koordinaten gespeichert. Der Transform des RTSTerrain-GameObjects legt fest, wo dieses Koordinatensystem in der Welt liegt.

Kartenlokale Koordinaten

• Der Ursprung ist Vertex (0, 0), die Ecke von Zelle (0, 0). X und Z laufen von 0 bis map.WorldSize in Metern, Y zeigt nach oben.
• Vertex (x, z) liegt lokal bei (x × CellSize, height, z × CellSize); der Mittelpunkt von Zelle (x, z) liegt bei ((x + 0.5) × CellSize, …, (z + 0.5) × CellSize).
• Lokales Y = 0 entspricht Stufe 0 mit einer Feinhöhe von 0. Bei einer neuen Karte mit Grundstufe 2 und 2 m hohen Stufen liegt der Boden bei lokalem Y = 4 m.
• Die Chunk-GameObjects liegen unter einem verborgenen Kindobjekt RTS Chunks des Terrains (RTSTerrain.ChunkRoot). Dieses Wurzelobjekt hat keinen lokalen Versatz und keine lokale Drehung und gleicht die Skalierung des Terrains aus; jeder Chunk hat einen lokalen Identitäts-Transform. Deshalb entspricht der Objektraum der Chunk-Meshes den kartenlokalen Koordinaten. Das ist wichtig, wenn du Shader für das Terrain schreibst.

Umrechnung zwischen Welt- und Kartenkoordinaten

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

Regeln für Position, Drehung und Skalierung

Mehrere Terrains

Eine Szene kann beliebig viele RTSTerrain-Komponenten enthalten. Jede davon hat eine eigene Karte, ein eigenes Tileset, eigene Bibliotheken und Chunks sowie eine eigene Pathing-Karte.

• RTSTerrain.All listet alle aktivierten Terrains auf; RTSTerrain.Main gibt das erste zurück (praktisch für Spiele mit nur einer Karte; temporäre Vorschau-Terrains werden übersprungen).
• RTSTerrain.FindAt(worldPosition) gibt das Terrain zurück, dessen XZ-Fläche eine Position enthält.
• RTSTerrain.RaycastAll(ray, out hit) führt einen Raycast gegen alle Terrains aus und gibt den nächstgelegenen Treffer zurück (hit.terrain verrät dir, welches Terrain getroffen wurde).
• RTSTerrain.TerrainEnabled / TerrainDisabled sind statische Events für Systeme, die Terrains verfolgen.
• Terrains sind unabhängig voneinander: Karten werden an ihren Rändern nicht zusammengefügt, und die Wegfindung (RTSPathfinder.FindPath(terrain, …)) arbeitet immer nur auf einem Terrain. Damit zwei Karten nahtlos aneinanderstoßen, gib ihren Randvertices dieselben Höhen.

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

Karten-Assets und Kartendateien

Eine Karte wird als .rtsmap-Datei gespeichert. Der Unity Editor (als Asset in deinem Projekt) und der In-Game-Editor (als Datei auf dem Datenträger) verwenden dasselbe Binärformat. Deshalb kannst du von Spielern erstellte Karten in Unity öffnen und umgekehrt.

.rtsmap-Dateien im Projekt

Findet Unity eine .rtsmap-Datei im Ordner Assets, wandelt der Importer RTSMapImporter sie in ein RTSMapAsset um. Das Asset speichert die komprimierten Dateibytes, einen kleinen Header (Name, Autor, Größe, Spieler, Tileset-ID) und eine Minikarten-Vorschau, die auch als Vorschaubild im Project-Fenster dient.

Ein Karten-Asset erstellen

• Tools ▸ RTS Terrain Studio ▸ New Map Wizard...: geführte Einrichtung (Grundlagen, Größe, Aussehen, Terrain); schreibt die Datei und erstellt dafür ein Terrain oder weist sie dem ausgewählten Terrain zu.
• Assets ▸ Create ▸ RTS Terrain Studio ▸ Map (.rtsmap): erstellt im ausgewählten Ordner eine flache Karte der Größe 128 × 128 mit Standardeinstellungen.
• Save As… im Fenster von RTS Terrain Studio: schreibt die aktuelle Karte eines Terrains in eine neue Datei.
• Kopiere eine mit dem In-Game-Editor erstellte .rtsmap-Datei in den Ordner Assets; sie wird wie jede andere Datei importiert.

Der Inspector des Karten-Assets

Wenn du ein Karten-Asset auswählst, siehst du Vorschau, Name, Autor, Beschreibung, Größe, Spieler, Tileset und Formatversion sowie Statistiken (Zellen, Weltgröße, Zellgröße, Stufenhöhe, Startpositionen, Bäume, Dekor, Regionen, Marker, Detailschichten, Dateigröße, Speicher, letzte Änderung).

Die Vorschau wird automatisch neu gebacken, wenn das Tileset mit der ID der Karte hinzugefügt oder entfernt wird oder seine Minikartenfarben ändert. Das Neuerstellen der Textur-Arrays importiert Karten nicht neu. Eine beschädigte Datei wird als leeres Asset mit Fehler-Icon importiert, und in der Console erscheint ein Importfehler.

Bearbeiten, Save und Save As

Weise ein Karten-Asset dem Feld Map Asset eines RTSTerrain zu. Sobald das Terrain aktiviert ist, lädt es die Karte in den Speicher, und alle Änderungen erfolgen an dieser Kopie im Speicher. Die Szenendatei speichert nur den Verweis auf das Asset, nie die Kartendaten selbst.

• Save (in der Kopfzeile des Fensters von RTS Terrain Studio oder Save Map im Optionsmenü des Overlays RTS Terrain Studio in der Scene View) schreibt die Karte zurück in ihre .rtsmap-Datei und importiert sie neu. Save ist hervorgehoben, solange nicht gespeicherte Änderungen vorliegen.
• Save As… schreibt eine neue Datei und weist sie dem Terrain zu, ohne neu zu laden. Dein Undo-Verlauf bleibt dabei erhalten.
• Open… lädt ein anderes Karten-Asset; Reload lädt die Karte neu aus ihrem Asset und verwirft nicht gespeicherte Änderungen.
• Ein Terrain ohne Karten-Asset erstellt eine Karte aus seinen Default Map Settings. Diese Karte existiert nur im Speicher, bis du Save As verwendest.
• Beim Speichern der Szene (Ctrl+S) werden auch die bearbeiteten Karten der Terrains dieser Szene gespeichert. Für neue Karten ohne Datei wird Save As angeboten. Beide Verhaltensweisen kannst du im Optionsmenü des Overlays in der Scene View ausschalten (Save Maps When Saving the Scene, Offer Save As for New Maps).
• Wenn du mit nicht gespeicherten Kartenänderungen den Play Mode startest, eine Szene schließt oder Unity beendest, wirst du gefragt, ob du sie speichern möchtest. Auch Änderungen, die du im Play Mode vornimmst (mit den Werkzeugen in der Scene View oder im In-Game-Editor), werden dir beim Verlassen des Play Mode zum Speichern angeboten.

Kartendateien zur Laufzeit

Im fertigen Spiel sind Karten gewöhnliche Dateien auf dem Datenträger:

• RTSMapSerializer.DefaultMapsFolder ist der Ordner Maps in RTSMapSerializer.StorageRoot, also in Application.persistentDataPath. Unter Windows ist der Ordner daher typischerweise %USERPROFILE%\AppData\LocalLow\<Company>\<Product>\Maps. In Web-Builds ist StorageRoot ein Ordner im Browserspeicher (siehe Karten im Browser).
• Der In-Game-Editor (RTSRuntimeEditor) speichert und öffnet Karten in seinem Maps Folder (leer = der oben genannte Standardordner; relative Pfade beziehen sich auf RTSMapSerializer.StorageRoot). Ist Write Preview Images aktiviert, schreibt er neben jede gespeicherte Karte ein kleines Minikartenbild Name.preview.png für seinen Kartenbrowser.
• Um eine Karte weiterzugeben, kopiere die .rtsmap-Datei in den Kartenordner eines anderen Spielers oder in ein Unity-Projekt. In einem Webbrowser verwende stattdessen die Befehle Download Map und Import Map des In-Game-Editors.
• Karten, die zum Lieferumfang deines Spiels gehören, können ganz normale Karten-Assets sein, auf die ein Terrain oder ein Skript verweist. Sie werden wie jedes andere Asset in den Build aufgenommen.

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

Ein Tileset (RTSTileset) legt das Aussehen einer Karte fest: bis zu 16 Bodenschichten, bis zu 4 Klippenschichten und den Stil des Wassers – vergleichbar mit den Sommer-, Winter- oder Wüsten-Tilesets klassischer RTS-Karteneditoren. Du kannst beliebig viele Tilesets anlegen und das Tileset eines Terrains jederzeit wechseln: Texturierte Karten speichern nur Schichtindizes, deshalb kann dieselbe Karte als Sommer- und als Winterkarte erscheinen.

1. Erstelle ein Tileset über Assets ▸ Create ▸ RTS Terrain Studio ▸ Tileset.
2. Ziehe deine Bodentexturen auf den Abschnitt Ground Layers im Inspector. Pro Albedo-Textur wird eine Schicht angelegt. Passende Normal-Maps und Höhentexturen werden am Suffix im Dateinamen erkannt (zum Beispiel _n, _normal, _nrm, _normalgl, _h, _height, _disp). Roughness-, AO- und Metallic-Maps werden ignoriert, sodass du einen ganzen heruntergeladenen Texturordner ablegen kannst.
3. Füge auf dieselbe Weise Klippenschichten unter Cliff Layers hinzu.
4. Weise das Tileset dem Feld Tileset deines RTSTerrain zu.
5. Klicke im Abschnitt Texture Arrays einmal auf Build Texture Arrays (siehe Textur-Arrays).

Tileset-Felder

Felder der Bodenschichten

Felder der Klippenschichten

Klippenwände werden per Triplanar-Mapping in kartenlokalen Koordinaten texturiert. Klippentexturen brauchen daher kein spezielles UV-Layout.

Wasserprofil

Das Wasserprofil ist Teil des Tilesets. Es wird vom Wasser-Renderer, von der Pathing-Karte und von der Minikarte verwendet.

Tilesets per Code bearbeiten

Tilesets sind ScriptableObjects. Rufe nach dem Ändern von Feldern per Code tileset.NotifyChanged() auf, damit Terrains ihre Materialien aktualisieren. tileset.GetGroundLayer(index) und GetCliffLayer(index) geben für unbelegte Slots null zurück.

Textur-Arrays

Der Terrain-Shader zeichnet alle 20 Schichten in einem einzigen Durchgang. Deshalb werden alle Schichttexturen in zwei Textur-Arrays auf der GPU gepackt. Du erstellst diese Arrays nie selbst: Hinein kommen normale Unity-Texturen beliebiger Größe und beliebigen Formats, heraus kommen die Arrays.

Aufbau

• Das erste Klippen-Slice ist RTSTileset.CliffSliceOffset (16), die Gesamtzahl ist RTSTileset.TotalSlices (20).
• Die Höhe (Alpha) stammt aus der Height Map der Schicht (R-Kanal), sonst aus dem Albedo-Alpha, wenn Height From Albedo Alpha aktiviert ist, andernfalls ist sie konstant 0.5.
• Normalen werden beim Erstellen der Arrays entpackt. Deine Normal-Maps können daher wie gewohnt Unitys Normal-Map-Import (DXT5nm / BC5) verwenden. Schichten ohne Normal-Map erhalten eine flache Normale.
• Schichten ohne Albedo erhalten ein neutralgraues Slice mit dezentem Muster; der Shader wendet die Tönung trotzdem an.
• Jedes Slice hat eine vollständige Mip-Kette und nutzt trilineare Filterung. Quellen beliebiger Größe werden auf die gewählte Resolution skaliert.

Erstellte Arrays und der Laufzeit-Fallback

Die Arrays können auf zwei Wegen entstehen:

Der Abschnitt Texture Arrays zeigt eine Statusanzeige:

• Not built: Das Terrain verwendet Laufzeit-Arrays. Klicke einmal auf Build Texture Arrays.
• Up to date: Format, Größe, Anzahl der Mips und Speicherbedarf werden angezeigt.
• Outdated: Texturen, Auflösung oder Komprimierung haben sich geändert, oder die Arrays wurden für eine andere Plattform oder Texturkomprimierung erstellt. Erstelle sie neu, oder überlasse das dem nächsten Player-Build.
• Building: Eine Erstellung läuft oder ist geplant.

Der Abschnitt zeigt außerdem das Zielformat für die aktive Build-Plattform sowie die geschätzte Größe und Erstellungsdauer. Vor Erstellungen über 256 MB fragt er nach einer Bestätigung. Clear entfernt die erstellten Arrays.

Player-Builds

Player-Builds verwenden die erstellten Arrays unverändert, weil nur der Editor sie mit den Quelltexturen vergleichen kann. Veraltete Arrays werden deshalb direkt vor jedem Player-Build automatisch neu erstellt. Tilesets, für die nie Arrays erstellt wurden, verwenden weiterhin Laufzeit-Arrays. Die Details, auch zum Batch-Modus und zu -rtsAllowOutdatedTextureArrays, findest du unter Textur-Arrays in Player-Builds. Player-Builds geben außerdem die CPU-Kopie der erstellten Arrays bei der ersten Verwendung frei. Das spart etwa so viel Speicher, wie die Arrays auf der GPU belegen.

Per Code: tileset.HasValidBuiltArrays gibt an, ob die komprimierten Arrays verwendet werden. Im Editor müssen sie existieren und zu ComputeContentHash() passen. Ein Player-Build vertraut den erstellten Arrays, bis dein Code zur Laufzeit die Texturen der Schichten, die Auflösung oder die Komprimierung ändert. Dann greift er auf Laufzeit-Arrays zurück. Werte von ComputeContentHash() sind nur innerhalb des Editors oder innerhalb einer einzelnen Sitzung eines Player-Builds vergleichbar, weil der Editor den Importzustand der Texturen in den Hash einbezieht. Ist HasValidBuiltArrays false, erstellt RTSTerrain unkomprimierte Laufzeit-Arrays (RTSTextureArrayBuilder.Acquire). tileset.BuiltAlbedoArray / BuiltNormalArray stellen die erstellten Arrays bereit. Verwende in deinem eigenen Laufzeitcode RTSShaderReferences.FindShader(name) (und FindMaterial(name)) statt Shader.Find, damit die Suche auch in Player-Builds funktioniert.

Auto Build

Ist Auto Build aktiviert (Standard; eine Editor-Einstellung für alle Tilesets), werden bereits erstellte Arrays eine Sekunde nach einer Änderung von Texturen, Auflösung oder Komprimierung neu erstellt, und zwar mit schneller Komprimierung. Die erste Erstellung startest du immer von Hand. Eine abgebrochene oder fehlgeschlagene automatische Erstellung wird erst wiederholt, wenn sich der Inhalt oder das Zielformat ändert. Die Schaltfläche Build Texture Arrays komprimiert dagegen mit normaler Qualität, was etwas besser aussieht. Klicke deshalb vor der Veröffentlichung darauf.

Vegetationsbibliothek

Eine Vegetationsbibliothek (RTSVegetationLibrary) listet das Gras, die Pflanzen und die Bäume auf, die du malen kannst. Erstelle eine über Assets ▸ Create ▸ RTS Terrain Studio ▸ Vegetation Library und weise sie dem Feld Vegetation Library des RTSTerrain zu. Damit Vegetation angezeigt wird, braucht das Terrain außerdem eine Komponente RTSVegetationRenderer (der Inspector von RTSTerrain bietet an, sie hinzuzufügen).

Der Inspector hat zwei Tabs, Details und Trees, mit einem Raster aus Vorschaubildern. Lege Prefabs (Bäume), Texturen (Gras-Quads) oder Meshes (Detail-Meshes) darauf ab, um Einträge hinzuzufügen. Jeder Eintrag erhält eine stabile id, die von Karten verwendet wird; duplizierte Einträge erhalten automatisch neue IDs.

Detail-Prototypen

Details sind kleine Pflanzen in großer Zahl, die du über ihre Dichte malst (siehe Detaildichte). Sie werden in Blöcken von 16 × 16 Zellen erzeugt und mit dem internen prozeduralen Shader Hidden/RTS Terrain Studio/Detail gezeichnet, der Wind, Nebel des Krieges und Farbvariation übernimmt.

Baum-Prototypen

Bäume sind einzelne Instanzen (siehe Bäume und Dekorinstanzen), die du mit dem Werkzeug Place Trees platzierst.

GPU-Instancing

Instanzierte Bäume werden per GPU-Instancing gezeichnet. Deshalb sollte bei ihren Materialien Enable GPU Instancing eingeschaltet sein. Ist die Option bei einem Material aus, verwendet der Renderer automatisch eine versteckte Instancing-Kopie davon (die beim Bearbeiten mit dem Original synchron bleibt). Der Inspector der Bibliothek zeigt dann eine Infomeldung mit der Schaltfläche Enable, die das Material selbst korrigiert. Bei Details muss Instancing in den Materialien nicht aktiviert sein, weil sie immer mit dem prozeduralen Detail-Shader gezeichnet werden.

Per Code entfernst du Bauminstanzen mit RTSVegetationRenderer.RemoveTree(id) (zum Beispiel, wenn ein Arbeiter einen Baum abbaut) und findest sie mit TryFindNearestTree. Ihr GameObject oder ihren Collider-Stellvertreter liefert GetTreeObject(id).

Bibliotheken per Code bearbeiten

Karten speichern eine Palette von Prototyp-IDs. Löse einen Palettenindex daher über die Bibliothek auf:

• Bäume: vegetationLibrary.FindTree(map.TreePrototypeIds[tree.prototype]).
• Detailschichten: vegetationLibrary.FindDetail(layer.prototypeId).
• Dekor: decorLibrary.Find(map.DecorPrototypeIds[d.prototype]). Das Prefab einer Variante erhältst du mit prototype.GetPrefab(d.variant): 0 ist das Haupt-Prefab, und ungültige oder leere Varianten fallen auf das Haupt-Prefab zurück. VariantCount zählt das Haupt-Prefab mit.
• decorLibrary.GetCategories() listet die Kategorien in Anzeigereihenfolge auf (Prototypen ohne Kategorie erscheinen unter Misc).
• vegetationLibrary.EnsureUniqueIds() vergibt neue IDs an duplizierte Einträge.

Rufe nach dem Ändern einer Bibliothek per Code library.NotifyChanged() auf (die Methode löst das Event Changed der Bibliothek aus). Dann löst RTSTerrain das Event LibrariesChanged aus, und die Renderer aktualisieren sich. Es gilt dieselbe Regel wie für Tilesets.

Dekorbibliothek

Eine Dekorbibliothek (RTSDecorLibrary) listet die Props (Doodads) auf, die du platzieren kannst: Felsen, Ruinen, Zäune, Kisten, Gebäude oder jedes andere Prefab. Erstelle eine über Assets ▸ Create ▸ RTS Terrain Studio ▸ Decor Library und weise sie dem Feld Decor Library von RTSTerrain zu. Eine Komponente RTSDecorManager auf dem Terrain hält die Szene mit den platzierten Instanzen synchron.

Der Inspector zeigt die Prototypen als Raster mit automatisch erzeugten Vorschaubildern und einem Tab pro Kategorie (plus All). Ziehe Prefabs darauf, um sie der aktuellen Kategorie hinzuzufügen; mit einem Rechtsklick auf einen Kategorie-Tab benennst du ihn um. Prototypen ohne Kategorie erscheinen unter Misc.

Felder der Dekor-Prototypen

Grundflächen

• Bei einer kreisförmigen Grundfläche dient der X-Wert von Footprint Size als Radius, multipliziert mit der größten horizontalen Skalierung der Instanz.
• Eine rechteckige Grundfläche folgt der Drehung der Instanz (ihren auf den Boden projizierten X- und Z-Achsen) und ihrer X/Z-Skalierung. Eine gedrehte Mauer blockiert also genau ihre eigene Fläche.
• Es wird keine Grundfläche geschrieben, wenn die Form None ist, der Effekt None ist oder die Instanz das Flag DecorFlags.IgnorePathing hat.
• Verwende für flache Dekorationen, über die Einheiten hinweglaufen dürfen (Blumen, Schutt), nur Unbuildable und für massive Objekte Unwalkable.

Spawn-Modi

Instanziertes Dekor verhält sich beim GPU-Instancing genauso wie instanzierte Bäume: Materialien ohne Enable GPU Instancing werden über eine verborgene Kopie mit aktiviertem Instancing gezeichnet. Gespawnte Objekte werden in einem Pool wiederverwendet; RTSDecorManager.GetInstanceObject(id) liefert das gespawnte Objekt einer Instanz, und RTSDecorInstance.FromCollider(collider) ordnet einen Physik-Treffer wieder seiner Instanz zu.

Das Dateiformat .rtsmap

Dieser Abschnitt richtet sich an Programmierer, die Karten mit anderen Werkzeugen lesen, Konverter schreiben oder eigene Daten hinzufügen möchten. Um das Paket zu verwenden, brauchst du ihn nicht: RTSMapSerializer erledigt alles.

Binärer Aufbau

Alle Zahlen werden im Little-Endian-Format gespeichert. Strings verwenden das .NET-Format von BinaryWriter: eine 7-Bit-codierte Länge, gefolgt von UTF-8-Bytes.

Der Header ist nicht komprimiert, damit Kartenbrowser Name, Autor, Größe und Spielerzahl anzeigen können, ohne die Karte zu entpacken (RTSMapSerializer.TryReadHeader, TryReadHeaderFromFile, Struct RTSMapHeader). Leseroutinen springen anhand der Header-Länge an das Ende des Headers, sodass künftige Versionen weitere Header-Felder anhängen können.

Dateiabschnitte

Jeder Abschnitt hat den Aufbau [int32 tag][int32 length][payload]. Tags sind FourCC-Codes, die als Little-Endian gespeichert werden; das erste Zeichen steht also im niedrigsten Byte (DIMS = 0x534D4944). Arrays mit Rasterdaten werden als int32-Elementanzahl geschrieben, gefolgt von den rohen Elementen.

„Eigenschaften“ werden als int32-Anzahl geschrieben, gefolgt von Schlüssel/Wert-Paaren aus Strings. Die abgeleitete Pathing-Karte wird nicht gespeichert, sondern nur die manuellen Overrides.

Unbekannte Abschnitte, beschädigte Dateien und Versionierung

• Unbekannte Abschnitte werden übersprungen, und zwar anhand ihrer Länge. Ältere Versionen des Pakets können deshalb neuere Dateien mit zusätzlichen Abschnitten lesen, und deine eigenen Abschnitte führen bei anderen Leseroutinen nie zu Fehlern.
• Hat eine Datei eine neuere Formatversion als die Leseroutine, wird eine Warnung protokolliert und die Datei trotzdem gelesen; unbekannte Daten werden übersprungen.
• Passt die Elementanzahl einer Rasterschicht nicht zur Kartengröße, wird eine Warnung protokolliert; was passt, wird gelesen, der Rest übersprungen.
• Abgeschnittene oder beschädigte Dateien lösen immer denselben Ausnahmetyp aus: System.IO.InvalidDataException. Bei einer Datei mit falscher Magic-Kennung lautet die Meldung „Not an RTS Terrain Studio map file“.
• RTSMapSerializer.SaveToFile schreibt zuerst in <path>.tmp und ersetzt dann die Datei. Ein Absturz während des Speicherns hinterlässt deshalb nie eine halb geschriebene Karte.
• Kompatibilitätsregel für das Format: Neue Daten kommen als neue Abschnitte oder als angehängte Header-Felder hinzu, nie durch Änderungen an bestehenden Abschnitten. Halte es mit deinen eigenen Abschnitten genauso und speichere eine Versionsnummer in deinen Nutzdaten.

Eigene Dateiabschnitte

Du kannst eigene Daten in Kartendateien speichern, etwa Spielregeln, Trigger oder Questdaten. Möglich machen das zwei statische Hooks von RTSMapSerializer:

• Wähle Tags, die nicht mit den eingebauten kollidieren; beginne sie mit X (zum Beispiel XGLD). Verwende nie 0, denn dieser Wert markiert das Ende der Abschnitte.
• Beide Hooks sind einfache Delegates: Kombiniere Handler mit += und entferne sie mit -=. So können mehrere Systeme Abschnitte beisteuern.
• Prüfe in deiner Leseroutine das Tag und ignoriere Abschnitte, die nicht von dir stammen.
• MapData bietet keinen Platz für deine Daten. Verwalte sie neben der Karte (das Beispiel verwendet eine ConditionalWeakTable). So abgelegte Daten kopieren MapData.Clone() und ResizeMap nicht mit, und sie werden auch nicht im Undo-Verlauf erfasst.
• Registriere die Hooks, bevor eine Karte geladen oder gespeichert wird. Im Unity Editor liest auch der Importer Karten, und Save schreibt sie; registriere die Hooks deshalb auch für den Editor (das Beispiel verwendet 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();
        }
    }
}

Im Spielcode greifst du mit StartingGoldSection.Get(terrain.Map).startingGold darauf zu. Wenn du den Wert im Editor änderst, markiere die Karte anschließend als geändert (zum Beispiel mit terrain.NotifyChanged(MapLayers.Info, terrain.Map.CellBounds) oder indem du terrain.HasUnsavedChanges = true setzt), damit sie gespeichert wird.

Das Fenster von RTS Terrain Studio

Das Fenster ist die Schaltzentrale des Editors. Es hat keinen eigenen Bearbeitungszustand: Es zeigt und ändert die gemeinsame Bearbeitungssitzung, die auch die Scene View, das Overlay der Scene View und der Inspector von RTS Terrain verwenden. Was du an einer Stelle änderst, erscheint sofort auch an den anderen.

Du kannst es auf folgende Arten öffnen:

• Tools ▸ RTS Terrain Studio ▸ Editor Window
• über die Schaltfläche Open RTS Terrain Studio im Inspector von RTS Terrain
• über die Fenster-Schaltfläche im Overlay von RTS Terrain Studio in der Scene View

Das Fenster hat vier Bereiche: oben die Kopfzeile, die Tab-Leiste, die scrollbare Seite und unten die Statusleiste.

Werkzeugseiten

Jeder Kategorie-Tab zeigt mehrere untereinander gestapelte Panels. Jedes Panel lässt sich mit einem Klick auf seine Kopfzeile einklappen.

Panel	Inhalt
Kategorie Tools	Das Werkzeugraster. Klicke auf ein Werkzeug, um damit in der Scene View zu malen. Klicke erneut auf das aktive Werkzeug, um die Bearbeitung zu beenden. Fahre mit der Maus über ein Werkzeug, um seine Beschreibung und seine Zusatztasten zu lesen. Eigene Werkzeuge, die du schreibst, erscheinen hier automatisch.
Werkzeug-Panel	Name, Beschreibung und Hinweis des ausgewählten Werkzeugs, eine Schaltfläche ?, die den passenden Abschnitt dieses Handbuchs öffnet, und eine Live-Statuszeile. Bewege die Maus über das Terrain, um sie zu sehen, zum Beispiel Ground 4.25 m | Fine +0.25 m | Level 2 bei Höhenwerkzeugen oder Level 2 → 3 bei den Klippenwerkzeugen.
Getting Started	Wird angezeigt, wenn kein Werkzeug dieser Kategorie ausgewählt ist. Malst du gerade mit einem Werkzeug einer anderen Kategorie, steht dort Active tool: X, und das Panel bietet Go to Tool an.
Brush	Form, Radius, Stärke, Härte, Abnahmekurve, Drehung, zufällige Drehung, Abstand und Streuung. Alle Pinselwerkzeuge teilen sich diese Einstellungen. Bei Werkzeugen, die keinen Pinsel verwenden, ist das Panel ausgeblendet. Siehe Pinsel.
Symmetry	Symmetriemodus und Symmetriezentrum (bei Ziehwerkzeugen nicht angezeigt). Siehe Symmetrie.
Werkzeug Settings	Die Einstellungen des ausgewählten Werkzeugs, automatisch aus dem Code des Werkzeugs erzeugt. Sie bleiben über Editorsitzungen hinweg erhalten. Die Tabellen in der Werkzeugreferenz führen jede Einstellung auf.
Kategorieaktionen	Zusätzliche Panels für einige Kategorien: Auto Paint Whole Map (Paint), Selection (Decor, solange Select Decor aktiv ist), Water at Cursor (Water) und Pathing Overlay (Pathing).

Solange die Bearbeitung pausiert ist, zeigt ein Banner Editing is paused – the Scene View uses Unity's tools. Mit der Schaltfläche Resume darin schaltest du die Bearbeitung wieder ein.

Tab Map

Der Tab Map enthält kartenweite Einstellungen und Operationen. Jede Änderung lässt sich rückgängig machen, sofern der zugehörige Dialog nichts anderes angibt. Die Schaltfläche ? oben öffnet diesen Abschnitt.

Tab Settings

Malen in der Scene View

Die gesamte Bearbeitung findet in der Scene View statt. Wenn die Terrain-Bearbeitung eingeschaltet und ein Werkzeug ausgewählt ist, malt die linke Maustaste mit dem Werkzeug, statt Objekte auszuwählen. Du schaltest die Bearbeitung mit der Schaltfläche Editing im Fenster, der Schaltfläche Start Editing im Overlay, der Schaltfläche Edit Terrain im Inspector oder durch einen Klick auf ein Werkzeug ein. Ausschalten kannst du sie mit 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 ...
        }
    }
}

Tastenkürzel

Die Tastenkürzel der Scene View sind in Unitys Shortcut Manager in der Kategorie RTS Terrain Studio registriert. Sie sind nur aktiv, wenn drei Bedingungen erfüllt sind: Die Terrain-Bearbeitung ist eingeschaltet, eine Scene View oder eines der Editorfenster von RTS Terrain Studio hat den Tastaturfokus (oder die Maus befindet sich über einer Scene View), und du tippst gerade nicht in ein Text- oder Zahlenfeld. Außerhalb der Bearbeitung behalten Tasten wie R oder die Zifferntasten ihre normale Funktion in Unity.

Diese Tasten und Mausaktionen verarbeitet das Paket selbst; sie lassen sich nicht neu belegen:

Die folgenden Tasten sind Unitys eigene Tastenkürzel und Befehle. RTS Terrain Studio reagiert auf sie, sie folgen aber dem, was du ihnen in Edit ▸ Shortcuts... unter Unitys Kategorien (Main Menu/Edit, Tools) zuweist:

R ist bei Select Decor der paketeigene Eintrag RTS Terrain Studio/Toggle Random Rotation: Solange Select Decor aktiv ist, wechselt er zu Unitys Werkzeug Scale, statt die zufällige Drehung umzuschalten.

Pinsel

Alle Pinselwerkzeuge teilen sich denselben Pinsel. Du stellst ihn im Panel Brush jeder Werkzeugseite, im Overlay (Size und Strength) oder mit den Tastenkürzeln ein. Der Pinsel bleibt zwischen Editorsitzungen erhalten.

Symmetrie

Symmetrie wiederholt jeden Tupfer, jeden Klick und jedes platzierte Objekt an gespiegelten oder gedrehten Positionen. So baust du faire Wettkampfkarten: Jeder Spieler bekommt dieselben Hügel, Klippen, Rampen, Bäume und Goldminen. Wähle den Modus im Panel Symmetry oder im Overlay. Magentafarbene Hilfslinien in der Scene View zeigen die Achsen und das Zentrum.

Centre ist das Symmetriezentrum in normierten Kartenkoordinaten: (0.5, 0.5) ist die Kartenmitte und der Standardwert. Reset setzt es dorthin zurück. Wenn du das Zentrum verschiebst, können einige Kopien außerhalb der Karte landen und werden dann übersprungen; das Panel zeigt eine Warnung.

Rückgängig und Wiederherstellen

Jede Terrain-Bearbeitung wird im eigenen Undo-Verlauf der Karte aufgezeichnet, der mit Unitys Undo-System verknüpft ist. Ctrl+Z, Ctrl+Y und das Menü Edit ▸ Undo funktionieren für Terrain-Bearbeitungen genau wie für jede andere Änderung, und das Edit-Menü zeigt den Namen des Schritts an, zum Beispiel Undo Raise / Lower. Die Schaltflächen Undo und Redo in der Kopfzeile des Fensters tun dasselbe und halten Unitys Verlauf synchron. Machst du zwischendurch eine Änderung an einem anderen Objekt rückgängig, bringt das den Terrain-Verlauf nicht durcheinander.

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

Werkzeugreferenz

Die folgenden Abschnitte beschreiben alle Werkzeuge der acht Kategorien. Alle Werkzeuge funktionieren im Unity Editor und im In-Game-Editor gleich. Einige Konventionen gelten für alle:

• ID ist die eindeutige Kennung des Werkzeugs. Du verwendest sie im Code, zum Beispiel RTSEditorContext.ActivateTool("height.raise").
• Eingabe: Pinselwerkzeuge malen, während du ziehst. Klickwerkzeuge wirken einmal pro Klick. Ziehwerkzeuge arbeiten mit Drücken, Ziehen und Loslassen (Rechtecke, Rechteckauswahl).
• Wiederholungen: Tupfer pro Sekunde, während du die Maustaste gedrückt hältst, ohne die Maus zu bewegen.
• Shift kehrt die Wirkung um und Ctrl+Klick nimmt einen Wert auf, sofern die Tabelle das angibt.
• Jede Einstellung ist mit Bereich und Standardwert aufgeführt. Die Einstellungen bleiben über Editorsitzungen hinweg erhalten. Reset All Tool Settings im Tab Settings stellt die Standardwerte wieder her.

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

Höhenwerkzeuge

Höhenwerkzeuge formen die Feinhöhe: Hügel, Täler, Straßen und natürliche Details über den Klippenstufen. Sie ändern nie die Klippenstufen, daher bleiben Klippenwände scharf. Die Statuszeile zeigt Bodenhöhe, Feinhöhe und Klippenstufe unter dem Cursor.

Einstellungen von Raise / Lower

Einstellungen von Smooth

Einstellungen von Flatten

Einstellungen von Set Height

Einstellungen von Noise

Einstellungen von Terrace

Einstellungen von Erode

Klippenwerkzeuge

Klippenwerkzeuge ändern die Klippenstufe von Vertices (0–15) und das Aussehen der Klippenwände zwischen den Stufen. Der Pinsel rastet an Vertices ein und wirkt als harte Auswahl: Du malst immer ganze Vertices, nie halbe Stufen. Die Statuszeile zeigt die Stufe unter dem Cursor und die Stufe, die du gleich malst, zum Beispiel Level 2 → 3.

Einstellungen von Raise / Lower Level

Die Zielstufe ergibt sich aus dem Vertex unter dem Cursor zu Beginn des Pinselstrichs: eine Stufe höher (oder mit Shift eine Stufe tiefer). Beim Ziehen wird genau diese Stufe gemalt, sodass du ein Plateau erweitern kannst, ohne Stufen übereinanderzustapeln. Das Werkzeug hebt Vertices nur an (bzw. senkt sie nur ab).

Einstellungen von Set Level

Ramp

Ramp hat keine Einstellungen. Eine Zelle wird zur Rampe, wenn alle vier Eckvertices mit dem Rampen-Flag markiert sind und die Zelle einen Höhenunterschied von genau einer Stufe überbrückt. Die Statuszeile hilft dabei: Sie zählt die gültigen Rampenzellen unter dem Pinsel, weist auf markierte Zellen ohne Stufenunterschied hin und warnt, wenn eine Rampe mehr als eine Stufe überbrückt (sie würde dann gestreckt).

Einstellungen von Cliff Type

Einstellungen von Clean Cliffs

Automatische Klippenkanten

In klassischen RTS-Karteneditoren verändert das Anheben einer Klippe auch den Boden daneben. Die Klippenwerkzeuge machen es genauso: Am Ende eines Pinselstrichs wird der Boden entlang jeder neuen Klippenkante mit der Kanten-Bodenschicht des Klippentyps bemalt, zum Beispiel mit einem steinigen Rand aus „Rocky Dirt“. Der Rand folgt der abgerundeten Klippenkontur, läuft über die mit Edge Width eingestellte Breite aus und hat einen leicht unregelmäßigen Umriss. So wirkt er natürlich statt wie aus Zellen zusammengesetzt.

1. Wähle das Tileset aus und öffne den Bereich Cliff Layers. Wähle auf jedem Klippen-Panel unter Edge Layer eine Schicht aus (die Demo-Tilesets verwenden Rocky Dirt).
2. Wähle Raise / Lower Level, Set Level, Ramp oder Clean Cliffs und lasse Paint Cliff Edges eingeschaltet.
3. Male Klippen wie gewohnt. Der Rand erscheint, sobald du die Maustaste loslässt.

• Ein Undo-Schritt: Stufenänderung und Kantenbemalung werden gemeinsam rückgängig gemacht.
• Symmetrie: Alle Symmetriekopien erhalten ihre Kanten im selben Durchgang.
• Rampen: Rampenzellen erhalten nie einen Rand. Wenn du eine Rampe über eine Kante malst, wird der Rand dort entfernt, sofern Clean Up Old Edges eingeschaltet ist.
• Verschobene Klippen: Ist Clean Up Old Edges eingeschaltet, wird der Rand einer verschwundenen Kante (abgesenktes oder erweitertes Plateau) wieder entfernt. Dabei wird die Kantenschicht auch dann entfernt, wenn du sie dort von Hand gemalt hast.
• Optional: Schalte Paint Cliff Edges für ein Werkzeug aus oder setze für das ganze Tileset die Einstellung Edge Layer des Klippentyps auf None. Ist die Option eingeschaltet, aber keine Kantenschicht festgelegt, weist die Statuszeile darauf hin.

Malwerkzeuge

Malwerkzeuge tragen die Bodenschichten des Tilesets auf (bis zu 16). Jedes Splat-Texel speichert die Gewichtungen aller Schichten, die zusammen immer 100 % ergeben. Fehlt die ausgewählte Schicht im Tileset oder hat sie keine Textur, weist die Statuszeile darauf hin, statt stillschweigend mit einem Ersatz zu malen.

Einstellungen von Paint Layer

Einstellungen von Tile Paint

Einstellungen von Fill / Replace

Jeder Klick ist ein Undo-Schritt, der nur den tatsächlich geänderten Bereich aufzeichnet.

Einstellungen von Smooth Paint

Einstellungen von Auto Paint

Der Tab Paint zeigt außerdem das Panel Auto Paint Whole Map, das die gesamte Karte in einem Schritt anhand des Profils neu bemalt.

Vegetationswerkzeuge

Vegetationswerkzeuge malen Gras und Kleinpflanzen (Details) und platzieren Bäume aus der Vegetation Library des Terrains. Hat das Terrain keine, bietet die Werkzeugseite die Schaltfläche Create Vegetation Library an. Wähle Prototypen im Raster aus; ist keiner ausgewählt, wird der erste Prototyp der Bibliothek verwendet.

Einstellungen von Paint Details

Einstellungen von Erase Details

Einstellungen von Place Trees

Einstellungen von Erase Trees

Dekorwerkzeuge

Mit den Dekorwerkzeugen platzierst, löschst und bearbeitest du Props wie Felsen, Ruinen und Zäune aus der Decor Library des Terrains. Hat das Terrain keine, bietet die Werkzeugseite die Schaltfläche Create Decor Library an. Das Prototyp-Raster hat ein Suchfeld und Kategoriefilter.

Einstellungen von Place Decor

Einstellungen von Erase Decor

Einstellungen von Select Decor

Panel Selection

Während Select Decor aktiv ist, zeigt der Tab Decor das Panel Selection mit der Anzahl der ausgewählten Objekte. Jede Bearbeitungsschaltfläche (Delete, Duplicate, Snap to Ground, Rotate 90°, Lock, Unlock) erzeugt genau einen Undo-Schritt. Select All und Clear ändern nur die Auswahl.

Das Verschieben, Drehen und Skalieren mit Handles ist unter Handles der Dekorauswahl beschrieben.

Wasserwerkzeuge

Wasser wird pro Vertex gespeichert: Ein Vertex ist entweder nass – dann hat er eine Höhe für die Wasseroberfläche – oder trocken. Wie die Klippenwerkzeuge arbeiten die Wasserwerkzeuge mit einer harten Auswahl. Das Panel Water at Cursor zeigt Wasserstand und Wassertiefe unter dem Mauszeiger und ob die Stelle als Flachwasser (begehbar) oder Tiefwasser gilt, gemessen an der Flachwassergrenze des Tilesets.

Einstellungen der Wasserhöhe (Paint Water und Flood Fill)

Einstellungen von Paint Water

Einstellungen von Flood Fill

Pathing-Werkzeuge

Die Pathing-Karte (begehbar, bebaubar, befliegbar, Wasser) wird automatisch aus Neigung, Klippen, Wasser, Bodenschichten, Bäumen und Dekor abgeleitet. Die Pathing-Werkzeuge malen manuelle Overrides darüber und verwenden dabei eine harte Auswahl in Pathing-Zellen. Schalte das Overlay im Panel Pathing Overlay oder mit P ein, um das Ergebnis zu sehen.

Einstellungen von Paint Pathing

Farben des Pathing-Overlays

Die Regeln für den automatischen Teil (maximale Neigungen, Klippenabstand usw.) stellst du in der Komponente RTS Terrain ein; siehe Pathing Rules.

Marker-Werkzeuge

Marker-Werkzeuge ergänzen die Karte um Gameplay-Informationen: wo die Spieler starten, benannte Regionen für Trigger und benannte Punkte wie Kamerapositionen. Marker werden in der Scene View gezeichnet, solange ein Marker-Werkzeug aktiv oder Show Markers eingeschaltet ist.

Einstellungen von Start Locations

Einstellungen von Regions

Neue Regionen erhalten automatisch einen eindeutigen Namen.

Einstellungen von Markers

Auto Paint

Auto Paint malt die Bodenschichten anhand der Form des Terrains: Gras auf flachem Boden, Fels an steilen Hängen und entlang von Klippen, Sand am Ufer und durch Rauschen aufgelockerte Erdflecken. So lässt du eine frisch modellierte oder generierte Karte am schnellsten fertig aussehen. Anschließend kannst du von Hand nacharbeiten.

Es gibt drei Möglichkeiten, Auto Paint zu nutzen:

• das Pinselwerkzeug Auto Paint im Tab Paint: Es malt die Regeln innerhalb des Pinsels und überblendet sie entsprechend Pinselgewichtung und Stärke mit der vorhandenen Texturierung. Mit Shift malt es stattdessen die Basisschicht und entfernt damit, was die Regeln gemalt haben;
• das Panel Auto Paint Whole Map im Tab Paint: Es texturiert jedes Bodentexel der Karte in einem einzigen Undo-Schritt neu. Es hat ein Feld Profile und eine Schaltfläche Create Profile;
• die Schaltfläche Apply To Map im Inspector des Profils sowie die Paint-Phase des Generators.