RTS Terrain Studio

Comment une carte est construite

Si vous avez déjà utilisé l’éditeur de cartes d’un RTS classique, la plupart de ces notions vous sembleront familières. Une carte est une grille de cellules carrées (2 m de large par défaut). Les coins des cellules sont les vertices, et la plupart des données sont stockées par vertex ou dans des textures haute résolution qui couvrent la carte.

Dans une scène, une carte se trouve sur un GameObject doté du composant RTSTerrain. Le menu GameObject ▸ RTS Terrain Studio ▸ RTS Terrain y ajoute aussi les composants des sous-systèmes (RTSVegetationRenderer, RTSWaterRenderer et RTSDecorManager). Le terrain lit la carte depuis un fichier .rtsmap de votre projet (un RTSMapAsset). Les meshes des chunks, l’herbe et l’eau qu’il affiche sont générés à partir de ce fichier. Ils ne sont jamais enregistrés dans la scène, si bien que vos scènes restent légères.

Vos cinq premières minutes

C’est le moyen le plus rapide de voir tout fonctionner. Hormis l’import du package, aucune configuration n’est nécessaire.

1. Ouvrez Tools ▸ RTS Terrain Studio ▸ Validate Project et cliquez sur Fix All. Cette action configure URP, la renderer feature du brouillard de guerre, les textures de caméra utilisées par l’eau et l’espace colorimétrique. Avant toute modification, une boîte de dialogue de confirmation vous explique ce qui va changer.
2. Lancez Tools ▸ RTS Terrain Studio ▸ Create Demo Content. Une barre de progression s’affiche pendant la génération des textures, des modèles, des tilesets, des cartes et des scènes. Une fois l’opération terminée, la scène RTS Terrain Studio - Gameplay Demo est sélectionnée dans la fenêtre Project.
3. Double-cliquez sur cette scène pour l’ouvrir, puis appuyez sur Play.
4. Sélectionnez vos unités avec le bouton gauche de la souris (clic, ou glisser pour tracer un rectangle) et cliquez avec le bouton droit sur le sol pour les déplacer. Déplacez la caméra avec WASD ou les touches fléchées, zoomez avec la molette de la souris et appuyez sur F1 pour afficher toutes les commandes.
5. Quittez le Play Mode et ouvrez la scène RTS Terrain Studio - Editor Playground. Ouvrez Tools ▸ RTS Terrain Studio ▸ Editor Window, choisissez un outil et peignez dans la Scene View. Maintenez Shift enfoncée pour obtenir l’effet inverse (par exemple abaisser au lieu d’élever). Appuyez sur Ctrl+Z pour annuler.
6. Ouvrez la scène RTS Terrain Studio - In-Game Editor Demo et appuyez sur Play. Voici l’éditeur dont disposeront vos joueurs. Appuyez sur F5 pour tester la carte en jeu avec des unités, et sur F2 pour afficher ou masquer l’éditeur.

Par où commencer

Fonctionnalités

Chacun des outils d’édition ci-dessous existe à la fois dans l’éditeur Unity et dans l’éditeur en jeu, car les deux utilisent les mêmes classes d’outils (des sous-classes de RTSTool). Les noms de cette liste sont ceux que vous voyez dans l’interface utilisateur.

Les choix de conception en un coup d’œil

Voici les questions que l’on pose le plus souvent sur les outils de terrain pour RTS, et les réponses qu’y apporte RTS Terrain Studio.

Premier aperçu de l’API

Pour donner aux programmeurs une idée de l’API, voici un script complet. Il interroge le terrain sur le point où vous cliquez et calcule un chemin jusqu’à ce point avec le module de recherche de chemin intégré. Il ne nécessite ni colliders ni composants supplémentaires : placez-le sur n’importe quel GameObject d’une scène qui contient un RTSTerrain.

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

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

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

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

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

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

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

PathStatus vaut Success, Partial (jusqu’au point accessible le plus proche), NoPath ou InvalidStart. Le chapitre Guide de programmation présente l’ensemble de l’API.

Configuration requise

Arborescence des dossiers

Le package se trouve dans un seul dossier, par défaut Assets/RTSTerrainStudio. Vous pouvez déplacer ou renommer ce dossier : l’éditeur trouve la racine du package grâce à l’emplacement de RTSTerrainStudio.Runtime.asmdef, et le contenu de démo ainsi que la documentation sont retrouvés à partir de celle-ci.

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)

Contenu du package

Le package est livré sous forme de code source, de shaders et de ce manuel. Tout le contenu visuel (textures, modèles, tilesets, cartes et scènes) est généré sur votre machine par un script. Le téléchargement reste ainsi léger, et le contenu est soumis exactement à la même licence que le code.

Cartes de démo

Les trois cartes utilisent des cellules de 2 m, une hauteur de niveau de falaise de 2 m et le tileset Summer.

Carte	Taille	Symétrie	Description
Two Rivers (1v1).rtsmap	128 × 128 cellules	Rotate 2	Deux joueurs, deux rivières. Des gués peu profonds permettent de traverser les rivières partout, tandis que le lac central est profond. Des rampes mènent à des plateaux boisés parsemés de ruines et de camps abandonnés.
Four Kingdoms (4p).rtsmap	192 × 192 cellules	Rotate 4	Quatre royaumes, chacun sur ses propres hauteurs. Des rampes descendent vers les basses terres communes, et le centre est un sol corrompu où se dressent les ruines d’un ancien temple.
Sandbox.rtsmap	96 × 96 cellules	None	Une petite carte, presque entièrement plate, pour essayer les outils.

Icônes

Toutes les icônes de la fenêtre de l’éditeur, des Inspectors et de l’éditeur en jeu sont dessinées de façon procédurale par RTSIcons : elles restent nettes à toutes les tailles et fonctionnent dans les builds sans aucun asset de texture.

Installation et configuration

Ouvrir les scènes de démo

Les scènes de démo se trouvent dans RTSTerrainStudio/Samples/Scenes. Ouvrez-en une en double-cliquant dessus dans la fenêtre Project, ou choisissez-la à l’étape 3 de la fenêtre Welcome et cliquez sur Open.

Votre première carte

Une carte est rattachée à un GameObject RTS Terrain de votre scène et stockée dans un fichier .rtsmap de votre projet. La scène ne fait que référencer ce fichier ; c’est dans ce fichier que vos modifications sont enregistrées. Commencez avec une nouvelle scène pour pouvoir expérimenter librement :

1. Choisissez File ▸ New Scene et sélectionnez un modèle de scène URP (par exemple Basic (URP)).
2. Enregistrez la scène tout de suite avec Ctrl+S, par exemple sous Assets/MyMaps/FirstMap.unity. Les nouveaux fichiers de carte sont créés à côté de la scène enregistrée : votre carte et votre scène restent ainsi regroupées.

Ouvrir la fenêtre de l’éditeur

Ouvrez Tools ▸ RTS Terrain Studio ▸ Editor Window (l’assistant et la fenêtre Welcome peuvent l’ouvrir pour vous, et l’Inspector du composant RTS Terrain propose un bouton Open RTS Terrain Studio). Ancrez-la à côté de l’Inspector pour voir la Scene View en même temps.

Zone	Ce qui est affiché
En-tête	Sélecteur de terrain, nom de la carte (un point signale des modifications non enregistrées), Save, Save As…, Open…, Reload, Undo / Redo avec le nom de l’étape, un bouton d’aide et l’interrupteur Editing On / Editing Off.
Barre d’onglets	Huit catégories d’outils (Height, Cliffs, Paint, Vegetation, Decor, Water, Pathing, Markers), puis Map et Settings. Un point signale la catégorie de l’outil actif.
Page des outils	Grands boutons d’outils, un panneau qui décrit l’outil actif avec son état en direct, les panneaux Brush et Symmetry, ainsi que les paramètres et les palettes propres à l’outil (calques, niveaux de falaise, joueurs, arbres, décors).
Barre d’état	Cellule sous le curseur, niveau de falaise, hauteur et cheminement sous la souris, et mémoire d’annulation.

Les huit catégories et leurs outils :

Touche	Catégorie	Outils
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

Chaque outil est décrit en détail dans son propre chapitre (par exemple Outils de hauteur et Outils de falaise) ; la fenêtre elle-même est décrite dans La fenêtre RTS Terrain Studio.

Votre premier test en jeu

Il existe deux façons de jouer sur votre carte : avec le Demo Game en Play Mode, ou dans le jeu en cours d’exécution avec l’éditeur en jeu et son bouton 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");
        }
    }
}

Tutoriel de 10 minutes : votre première carte 1v1

Dans ce tutoriel, vous créez une petite carte équilibrée pour deux joueurs : chaque joueur dispose d’une base sur un plateau doté d’une rampe, une rivière sépare les deux moitiés et des forêts encadrent la carte. La peinture symétrique garantit que les deux côtés sont identiques : vous ne construisez donc qu’une seule moitié.

Pour aller plus loin

• Fenêtre de l’éditeur : chaque onglet, panneau et paramètre en détail, y compris l’onglet Map (redimensionnement, générateur, import et export de heightmaps, mini-carte, environnement).
• Les chapitres consacrés aux outils, un par catégorie : Height, Cliffs, Paint, Vegetation, Decor, Water, Pathing, Markers.
• Éditeur en jeu : livrez l’éditeur avec votre jeu et laissez les joueurs créer leurs propres cartes.
• Programmation : interrogez les hauteurs, les niveaux de falaise et le cheminement par le code, chargez des cartes à l’exécution et réagissez aux modifications.
• Intégrations : le multijoueur avec Mirror, la recherche de chemin avec l’A* Pathfinding Project ou Unity NavMesh.
• Dépannage : matériaux roses, eau plate, décalages lors de la peinture et autres problèmes courants.

Le Project Validator

Ouvrez Tools ▸ RTS Terrain Studio ▸ Validate Project, ou cliquez sur Validate dans la fenêtre Welcome. Les vérifications s’exécutent dès l’ouverture de la fenêtre. Elles sont réparties en cinq catégories :

Chaque résultat a l’un des quatre états suivants :

Le bouton Fix All applique toutes les corrections disponibles. Une boîte de dialogue récapitule d’abord toutes les modifications, et rien n’est changé tant que vous n’avez pas cliqué sur Apply Fixes. Les corrections qui nécessitent URP (les textures de caméra et la renderer feature du brouillard de guerre) s’exécutent automatiquement une fois le pipeline assigné : un seul clic suffit donc à configurer un nouveau projet. Le bouton Run Again relance les vérifications. La liste complète des vérifications, avec leurs boutons de correction, figure dans Valider le projet.

Exécuter les vérifications par le code

RTSProjectValidator.RunChecks() renvoie les résultats sans rien modifier, et RTSProjectValidator.FixAll() applique les corrections. Vous pouvez les utiliser dans un script de build ou dans un job d’intégration continue. L’exemple doit être placé dans un dossier Editor.

using UnityEditor;
using UnityEngine;
using RTSTerrainStudio.Editor;

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

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

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

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

Universal Render Pipeline

Tous les shaders du package sont écrits pour URP. Sans lui, le terrain, l’eau et la végétation s’affichent en rose, voire pas du tout. La correction Use URP utilise un asset URP existant du projet (ou crée Assets/Settings/RTS URP.asset avec un renderer) et l’assigne comme pipeline de rendu par défaut, ainsi qu’à chaque niveau de qualité qui utilise un autre pipeline. Pour faire la même chose à la main :

1. Si le projet n’a pas encore d’asset URP, créez-en un dans la fenêtre Project avec Create ▸ Rendering ▸ URP Asset (with Universal Renderer).
2. Assignez-le comme Default Render Pipeline dans Edit ▸ Project Settings ▸ Graphics.
3. Ouvrez Edit ▸ Project Settings ▸ Quality. Pour chaque niveau de qualité qui remplace le pipeline via Render Pipeline Asset, vérifiez que l’asset indiqué est lui aussi un asset URP.

Depth Texture et Opaque Texture

L’eau utilise la texture de profondeur de la caméra pour que sa couleur de profondeur, son écume et le fondu de son rivage suivent les objets posés dans l’eau, et la texture opaque pour la réfraction. Sans elles, l’eau paraît plus simple. Sélectionnez chaque asset URP utilisé par vos niveaux de qualité et cochez Depth Texture et Opaque Texture dans sa section Rendering, ou cliquez sur Enable Both dans le validateur.

La renderer feature du brouillard de guerre

La renderer feature RTS Fog Of War (RTSFogOfWarRendererFeature) dessine le brouillard de guerre par-dessus tout ce qui est à l’écran, y compris les unités et les accessoires qui utilisent vos propres matériaux. Sans elle, seuls les shaders du package affichent le brouillard de guerre. Le bouton Add Feature l’ajoute au renderer par défaut de chaque asset URP utilisé. Pour l’ajouter à la main, sélectionnez l’asset Universal Renderer Data, cliquez sur Add Renderer Feature et choisissez RTS Fog Of War. Les détails figurent dans Rendu : renderer feature et shader de repli.

Espace colorimétrique

Le package est conçu pour l’espace colorimétrique Linear, la valeur par défaut d’URP. En espace Gamma, les couleurs, l’éclairage et l’eau paraissent délavés par rapport aux captures d’écran. Réglez Edit ▸ Project Settings ▸ Player ▸ Other Settings ▸ Color Space sur Linear, ou cliquez sur Switch to Linear dans le validateur.

Packages requis

L’assembly d’exécution utilise Burst (com.unity.burst), Collections (com.unity.collections) et Mathematics (com.unity.mathematics) pour ses jobs et son modèle de données. Les scripts du package ne se compilent pas tant que l’un d’eux manque. Installez-les depuis Window ▸ Package Manager ▸ Unity Registry, ou cliquez sur Install dans le validateur, qui ajoute tous les packages manquants en une seule requête au Package Manager. Les versions testées sont indiquées dans Packages requis.

Gestion des entrées

Toutes les entrées à l’exécution (l’éditeur en jeu, la caméra et les unités d’exemple) passent par la classe statique RTSInput. Lorsque le package Input System (com.unity.inputsystem) est installé, l’assembly d’exécution est compilée avec le symbole RTS_INPUT_SYSTEM et utilise ce package. Sinon, ou lorsque le projet n’utilise que l’ancien Input Manager, RTSInput se rabat sur l’ancienne API UnityEngine.Input.

Ce paramètre se trouve dans Edit ▸ Project Settings ▸ Player ▸ Other Settings ▸ Active Input Handling. Unity demande de redémarrer l’éditeur lorsque vous le modifiez. La vérification Input handling ne modifie jamais ce paramètre à votre place, car le bon choix dépend de votre jeu. Voir aussi Gestion des entrées dans la configuration requise.

Shaders et contenu

• Package shaders compile. Si un shader du package présente des erreurs de compilation (les objets concernés s’affichent en rose), le bouton Reimport permet de le réimporter. C’est utile lorsque les shaders ont été importés avant la fin du chargement d’URP. Si des shaders requis manquent complètement, réimportez le package depuis l’Asset Store. Voir Dépannage.
• Shaders included in builds. Voir Générer le build de votre jeu.
• Tileset texture arrays built. Les tilesets sans tableaux construits à jour fonctionnent quand même, mais tant que les tableaux ne sont pas reconstruits, l’éditeur construit des tableaux sans compression au chargement de la carte, ce qui coûte de la mémoire et du temps de chargement. Le bouton Build Arrays les construit pour chaque tileset obsolète. La génération d’un build de joueur reconstruit automatiquement les tableaux obsolètes ; dans les builds de joueur aussi, les tilesets dont les tableaux n’ont jamais été construits utilisent des tableaux sans compression. Voir Tableaux de textures et Tableaux de textures dans les builds de joueur.
• GPU instancing on instanced prototypes. Les matériaux des arbres instanciés, des détails en mode Mesh et des objets de décor instanciés doivent avoir l’option Enable GPU Instancing cochée. Sinon, ils sont dessinés au moyen de copies temporaires, et leurs variantes d’instanciation peuvent être supprimées des builds de joueur. Le bouton Enable Instancing coche cette option sur chaque matériau listé qui peut être modifié. Les matériaux contenus dans un modèle ou dans un package sont en lecture seule : extrayez-les d’abord. Voir Instanciation GPU.
• Terrains have a tileset. Un terrain sans tileset affiche un aspect neutre de substitution. La correction assigne un tileset du projet à chaque terrain qui n’en a pas (opération annulable). Voir Tilesets.

Fichiers de carte des terrains de scène

Un RTS Terrain conserve sa carte dans un asset .rtsmap (son champ Map Asset). Un terrain qui n’en a pas ne garde sa carte qu’en mémoire, et vos modifications sont perdues à la fermeture de la scène. La vérification Terrains save to a map file liste ces terrains. Le bouton Create Map Files enregistre la carte actuelle de chaque terrain listé dans un nouveau fichier .rtsmap, placé dans le dossier de sa scène (ou dans Assets/Maps si la scène n’est pas encore enregistrée), puis l’assigne au terrain.

Les terrains créés avec le New Map Wizard ou avec le contenu de démo ont déjà un fichier de carte. Pour comprendre le fonctionnement des assets de carte et des commandes Save et Save As, lisez Assets de carte et fichiers de carte.

Générer le build de votre jeu

Unity n’intègre des shaders dans un build de joueur que si un matériau du build les utilise. RTS Terrain Studio crée les matériaux du terrain, de l’eau et du brouillard de guerre par le code à l’exécution ; les shaders sont donc référencés depuis l’asset Resources/RTSTerrainStudio/RTSShaderReferences.asset, situé dans le dossier du package. Cet asset référence aussi le matériau DecorPlaceholder, qui conserve dans le build les variantes d’instanciation d’URP Lit. L’asset est vérifié et mis à jour automatiquement après chaque rechargement des scripts, à chaque import de shaders et avant chaque build de joueur. Si la vérification Shaders included in builds est rouge, cliquez sur Update.

Avant de générer le build, passez en revue les points suivants :

1. Exécutez Tools ▸ RTS Terrain Studio ▸ Validate Project et corrigez toutes les erreurs et tous les avertissements.
2. Vérifiez que chaque niveau de qualité de votre plateforme cible utilise un asset URP avec Depth Texture et Opaque Texture, et que son renderer possède la renderer feature RTS Fog Of War si vous utilisez le brouillard de guerre.
3. Construisez une première fois les tableaux de textures de vos tilesets (Build Arrays dans le validateur, ou Build Texture Arrays dans l’Inspector du tileset), afin que le terrain n’ait pas à les construire sans compression au chargement. Les tableaux obsolètes sont reconstruits automatiquement avant chaque build de joueur (voir ci-dessous).
4. Si vos cartes utilisent le brouillard atmosphérique, assurez-vous que la vérification Fog kept in player builds indique OK (voir Brouillard atmosphérique dans les builds de joueur).
5. Validez vos cartes dans l’onglet Map (voir Validation des cartes).
6. Ajoutez vos scènes à la liste des scènes de votre profil de build. Les cartes assignées à un RTS Terrain dans une scène sont incluses comme n’importe quel autre asset référencé.
7. Si vous livrez l’éditeur en jeu, lisez Livrer l’éditeur en jeu avec votre jeu. Les cartes que les joueurs enregistrent à l’exécution sont placées dans le dossier Maps de RTSMapSerializer.StorageRoot (Application.persistentDataPath ou, dans les builds Web, le stockage du navigateur) ; voir Fichiers de carte à l’exécution.
8. Si vous réglez Managed Stripping Level sur un niveau supérieur à Minimal et que vous avez écrit vos propres outils d’édition, lisez Élagage du code et outils personnalisés.
9. Pour un build Web, lisez aussi Builds Web (WebGL).

Tableaux de textures dans les builds de joueur

Un build de joueur utilise tels quels les tableaux de textures construits d’un tileset, car seul l’éditeur peut les comparer aux textures sources. Pour qu’un build ne livre jamais d’anciennes textures de sol, chaque tileset dont les tableaux ont déjà été construits est vérifié juste avant le début d’un build de joueur :

• Les tableaux qui ne correspondent plus aux textures, à la résolution ou à la compression, ou qui ont été construits pour une autre plateforme ou une autre compression de textures, sont reconstruits avec une qualité de compression normale. Une barre de progression indique l’avancement.
• Les tilesets qui n’ont jamais été construits ne sont pas modifiés. Les builds de joueur construisent pour eux des tableaux sans compression au chargement d’une carte.
• Si une reconstruction est annulée ou échoue alors que les textures ou les paramètres ont changé, une boîte de dialogue propose Try Again, Cancel Build et Build Anyway. Les tableaux dont seul le format diffère affichent quand même les bonnes textures : dans ce cas, seul un avertissement est consigné.
• Un build en mode batch s’arrête dans ce cas. Ajoutez -rtsAllowOutdatedTextureArrays à la ligne de commande pour générer le build malgré tout, avec un avertissement par tileset.
• Un éditeur sans périphérique graphique (-nographics, fréquent sur les serveurs de build) ne peut pas construire de tableaux. Le build continue alors avec un avertissement par tileset obsolète, et les builds de joueur utilisent les tableaux tels qu’ils ont été construits la dernière fois. Construisez les tableaux dans l’éditeur avant un tel build.
• Les tableaux ne sont reconstruits que pour la plateforme de build active. Si vous générez un build pour une autre plateforme, le build consigne un avertissement à la place : passez d’abord sur cette plateforme.
• Les asset bundles et le contenu Addressables que vous construisez séparément ne déclenchent pas cette vérification. Construisez d’abord les tableaux.

Les tableaux construits sont stockés dans l’asset du tileset sous une forme lisible par le CPU. Les builds de joueur libèrent cette copie CPU à la première utilisation des tableaux, ce qui économise environ 14 Mo par tileset à 512 px et environ 56 Mo à 1024 px.

Brouillard atmosphérique dans les builds de joueur

RTSEnvironment active le brouillard atmosphérique stocké dans une carte pendant l’exécution du jeu. Unity supprime les variantes de shader des modes de brouillard qu’il juge inutilisés : lorsque Project Settings ▸ Graphics ▸ Shader Stripping ▸ Fog Modes est réglé sur Automatic, il ne conserve que le brouillard des scènes du build enregistrées avec le brouillard activé. RTS Environment rétablit le brouillard propre à la scène avant chaque enregistrement : son brouillard n’est donc pas pris en compte, et les cartes avec brouillard atmosphérique n’afficheraient aucun brouillard dans un build.

La vérification Fog kept in player builds parcourt les scènes du build du profil de build actif ainsi que les scènes ouvertes, et liste les modes de brouillard qu’y utilise RTS Environment. Le bouton Keep Fog Modes (également inclus dans Fix All) règle Fog Modes sur Custom et conserve exactement ces modes, en plus de ceux qui étaient déjà conservés. Chaque mode conservé ajoute des variantes de shader au build ; les modes inutilisés ne sont donc pas ajoutés. Si le profil de build actif surcharge les paramètres Graphics, vérifiez aussi son réglage Fog Modes.

Builds Web (WebGL)

RTS Terrain Studio fonctionne dans un navigateur web : le terrain, la végétation, l’eau, les décors, le brouillard de guerre, l’éditeur en jeu et les exemples. Un navigateur ne fonctionne cependant pas comme une plateforme de bureau : le joueur ne peut ouvrir aucun dossier, certaines touches appartiennent au navigateur, tout le code s’exécute sur un seul thread et l’ensemble du jeu partage un unique tas mémoire de taille limitée. Cette section explique comment le package gère ces contraintes et comment générer, tester et publier un build Web.

En bref :

1. Ouvrez File ▸ Build Profiles, sélectionnez Web et cliquez sur Switch Platform (ou faites de votre profil de build Web le profil actif).
2. Exécutez Tools ▸ RTS Terrain Studio ▸ Validate Project et cliquez sur Fix All. Lorsque Web est actif, le validateur installe aussi le modèle pleine fenêtre et vérifie les niveaux de qualité des builds Web.
3. Si vos cartes utilisent le brouillard atmosphérique, vérifiez que Fog kept in player builds indique OK.
4. Cliquez sur Build And Run. Unity génère le build du jeu et l’ouvre dans votre navigateur.

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

Le modèle de carte

Toutes les données d’une carte résident dans un seul objet de la classe MapData (espace de noms RTSTerrainStudio). Un composant RTSTerrain possède un MapData (terrain.Map), en assure le rendu sous forme de meshes de chunks, tient à jour la carte de cheminement qui en dérive et répond à des requêtes comme « à quelle hauteur se trouve le sol ici ? ».

Cellules et vertices

La carte est une grille de Width × Height cellules. Chaque cellule possède quatre vertices, un à chaque coin, et les cellules voisines partagent leurs coins. Une carte de 4 × 2 cellules compte donc 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)

• Les couches par vertex (hauteur fine, niveau de falaise, indicateurs, type de falaise, hauteur de l’eau) comptent (Width + 1) × (Height + 1) entrées, stockées ligne par ligne. Utilisez map.VertexIndex(x, z).
• La taille de cellule (map.CellSize, 2 m par défaut) est la taille réelle d’une cellule. Une carte de 128 × 128 cellules de 2 m couvre 256 × 256 m (map.WorldSize).
• Une position appartient à la cellule floor(localXZ / CellSize) ; map.LocalToCell(localXZ) effectue ce calcul et limite le résultat aux bornes de la carte.
• Pour le rendu, les cellules sont regroupées en chunks (16, 32 ou 64 cellules par côté, paramètre Chunk Size du composant RTSTerrain, 32 par défaut). Seuls les chunks touchés par une modification sont reconstruits. La taille de chunk ne modifie pas les données de la carte.

Dimensions de la carte

Les dimensions sont choisies à la création de la carte (dans le New Map Wizard, dans la boîte de dialogue New Map de l’éditeur en jeu ou avec MapCreationSettings dans le code). Les valeurs situées hors de la plage autorisée sont corrigées par MapCreationSettings.Validate().

Contenu d’une carte

Chaque type de données possède un indicateur correspondant dans l’énumération MapLayers. Ces indicateurs servent aux notifications de modification, à l’enregistrement des annulations et à la sérialisation.

Deux indicateurs combinés sont pratiques : MapLayers.Geometry (hauteurs, niveaux, indicateurs de vertex, types de falaise) et MapLayers.PathingInputs (tout ce qui influe sur la carte de cheminement). MapLayers.All couvre l’ensemble.

La carte de cheminement (terrain.Pathing, classe PathingMap) est une donnée dérivée : elle est calculée à partir des couches ci-dessus et n’est jamais enregistrée. Voir Carte de cheminement.

Niveaux de falaise, hauteurs fines et types de falaise

Le terrain des RTS classiques comporte deux sortes de hauteur : de grandes marches discrètes (les falaises) et de petites variations douces (les collines). RTS Terrain Studio stocke les deux séparément sur chaque vertex.

Niveaux de falaise

• Chaque vertex possède un niveau de falaise compris entre 0 et 15 (MapData.MaxCliffLevel = 15).
• Un niveau mesure CliffLevelHeight mètres de haut (2 m par défaut).
• Les nouvelles cartes démarrent au niveau 2 : il reste ainsi deux niveaux sous le sol pour les lacs, les rivières et les canyons, et treize au-dessus pour les plateaux.
• Modifiez les niveaux avec les outils de falaise : Raise / Lower Level, Set Level, Ramp, Cliff Type et Clean Cliffs.
• Le brouillard de guerre utilise les niveaux de falaise pour la ligne de vue : les unités voient leur propre niveau et ceux du dessous, tandis que les terrains plus élevés bloquent leur vision.

Hauteurs fines

En plus du niveau, chaque vertex possède une hauteur fine en mètres (Heights), positive ou négative. Les outils de hauteur (Raise / Lower, Smooth, Flatten, Set Height, Noise, Terrace, Erode) ne modifient que la hauteur fine, ce qui vous permet de créer des collines sur un plateau sans qu’elles deviennent des falaises. La hauteur du sol d’un vertex vaut :

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

Exemple : au niveau 3, avec une hauteur de niveau de 2 m et une hauteur fine de 0.4 m, le vertex se trouve à 6.4 m au-dessus de l’origine de la carte. map.GetVertexHeight(x, z) et map.GetVertexPosition(x, z) effectuent ce calcul pour vous.

Types de falaise

Un tileset peut contenir jusqu’à 4 calques de falaise (par exemple « Rock » et « Grassy Cliff »). Chaque vertex indique lequel utiliser (CliffTypes, 0–3, peint avec l’outil Cliff Type). Une paroi de falaise utilise le type de falaise du coin le plus haut de sa cellule. Si un indice de type de falaise ne correspond à aucun calque du tileset, la paroi se rabat sur le calque de falaise 0.

Construction de la surface (la surface de référence)

La structure MapGeometryView définit la seule et unique surface du terrain. Les meshes des chunks, les requêtes de gameplay (GetHeight, Raycast, …), la carte de cheminement et le brouillard de guerre suivent tous les mêmes règles, si bien que ce que vous voyez est exactement le sol sur lequel marchent les unités. Chaque cellule est classée d’après ses quatre coins :

Contours arrondis. Dans une cellule de falaise, pour chaque seuil de niveau t, la fonction indicatrice « niveau du coin ≥ t » (1 ou 0) est interpolée de façon bilinéaire sur la cellule. Un point appartient au niveau le plus élevé dont l’indicatrice interpolée vaut au moins 0.5 (MapGeometryView.LevelAt). Il s’agit d’une règle de type marching squares : un coin surélevé isolé produit un quart de cercle au lieu d’une diagonale, et les longues lignes de falaise restent droites. La paroi elle-même se dresse verticalement sur le contour. Les hauteurs fines sont toujours interpolées de façon bilinéaire et ajoutées par-dessus, y compris dans les cellules de falaise.

L’aspect des parois rendues se règle sur le composant RTSTerrain (Settings) :

Obtenez une vue avec map.GetGeometryView(). Il s’agit d’une structure de tableaux natifs, que vous pouvez donc aussi transmettre à des jobs Burst. Tous les membres attendent des positions locales à la carte :

Rampes

Une rampe permet aux unités de passer à pied d’un niveau de falaise au suivant. La règle est simple :

• L’indicateur est VertexFlags.Ramp, posé sur chaque vertex. L’outil Ramp (id cliff.ramp) le peint ; maintenez Shift enfoncée pour le retirer.
• Une cellule de rampe forme une pente bilinéaire lisse entre les hauteurs de ses coins (niveau plus hauteur fine).
• Les rampes donnent les meilleurs résultats lorsqu’elles franchissent exactement un niveau. Des rampes plus raides sont autorisées, mais la barre d’état signale les cellules de rampe qui s’étendent sur plus d’un niveau.
• Cheminement : pour une rampe valide d’un seul niveau, la praticabilité n’est testée que sur la pente due aux hauteurs fines (le dénivelé entre les niveaux qu’elle relie ne la rend pas « trop escarpée »). Les rampes ne sont jamais constructibles.
• Sur une rampe, GetCliffLevel renvoie le niveau interpolé, arrondi : le niveau inférieur sur la moitié basse, le niveau supérieur sur la moitié haute.

1. Surélevez un plateau d’un niveau avec l’outil Raise / Lower Level.
2. Sélectionnez l’outil Ramp et peignez en travers du bord de falaise, à l’endroit où la rampe doit se trouver. Le pinceau doit couvrir au moins les vertices des deux côtés de la paroi, afin que tous les coins des cellules intermédiaires reçoivent l’indicateur.
3. La paroi disparaît et une pente apparaît. Élargissez la rampe en peignant d’autres vertices le long du bord.

Calques de sol et splat maps

Les textures de sol sont peintes dans des splat maps : quatre textures RGBA (MapData.SplatMapCount = 4) de SplatWidth × SplatHeight texels. Chacun des 16 canaux contient le poids d’un calque de sol du tileset :

• Le calque i est stocké dans la splat map i / 4, canal i % 4. C’est pourquoi un tileset compte exactement 16 calques de sol : 4 splat maps × 4 canaux.
• La somme des poids d’un texel vaut toujours 255 sur l’ensemble des 16 canaux. Tous les outils de peinture respectent cet invariant ; le code qui écrit des données de splat doit le respecter lui aussi.
• La résolution de splat est le nombre de texels par côté de cellule (4 par défaut). Avec des cellules de 2 m, cela donne un texel tous les 0.5 m.
• Le centre du texel (x, z) se trouve en ((x + 0.5), (z + 0.5)) × CellSize / SplatResolution, en XZ local à la carte. La même formule s’applique aux texels de détail et de cheminement, avec leur propre résolution.
• Méthodes utilitaires : map.SplatIndex(x, z), map.GetSplatWeight(texelIndex, layer), map.GetDominantLayer(texelIndex), MapData.GetChannel / SetChannel et 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));
    }
}

Eau

• Un vertex est sous l’eau lorsqu’il porte l’indicateur VertexFlags.Water. La hauteur de la surface de l’eau (Y local à la carte, en mètres) est stockée dans WaterHeights ; cette valeur n’a de sens que là où l’indicateur est présent.
• Un point est immergé lorsque la couverture bilinéaire des indicateurs d’eau des quatre coins de sa cellule vaut au moins 0.5. Dans une cellule immergée, les coins sans eau utilisent la hauteur d’eau la plus élevée de la cellule, si bien que les rivages restent horizontaux.
• La profondeur d’eau = surface de l’eau − hauteur du sol. La profondeur détermine le cheminement : une eau plus profonde que le paramètre Shallow Depth Limit du tileset (0.9 m par défaut) est de l’eau profonde (non praticable), une eau moins profonde est de l’eau peu profonde (praticable, mais non constructible par défaut).
• Les outils d’eau sont Paint Water, Erase Water et Flood Fill. Les modifications d’eau ne notifient que MapLayers.Water, si bien que les chunks du terrain ne sont pas reconstruits pendant que vous peignez de l’eau.
• Requêtes : terrain.IsWater(world, out depth) et terrain.TryGetWaterHeight(world, out waterWorldY).

L’aspect de l’eau (couleurs, vagues, écume) provient du profil d’eau du tileset ; voir Profil d’eau.

Densité de détails (herbe et petites plantes)

• Les détails ne sont pas des objets individuels. Chaque prototype de détail utilisé sur la carte dispose d’un DetailLayer dans map.DetailLayers : un octet par texel de détail (DetailWidth × DetailHeight, 2 texels par côté de cellule par défaut).
• Une densité de 0 signifie vide, et 255 correspond à Max Density instances par texel (un champ du prototype de détail, 6 par défaut). Chaque texel fait apparaître density / 255 × maxDensity instances ; le moteur de rendu les disperse de manière déterministe, si bien qu’une même carte a toujours le même aspect.
• Les couches sont associées à la bibliothèque de végétation par leur prototypeId. map.GetOrAddDetailLayer(id) crée une couche à la demande ; map.FindDetailLayer(id) renvoie null si le prototype n’est pas utilisé.
• Peignez-les avec l’outil Paint Details et effacez-les avec l’outil Erase Details.

Arbres et instances de décor

Les arbres (TreeInstanceData) et les objets de décor (DecorInstanceData) sont stockés sous forme de simples listes. Au lieu d’un nom de prototype, chaque instance stocke un petit index de palette qui pointe vers une liste d’identifiants de bibliothèque enregistrée dans la carte :

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

• Utilisez map.GetOrAddTreePrototype(id) / map.GetOrAddDecorPrototype(id) pour obtenir l’index de palette d’un identifiant de bibliothèque (il est ajouté s’il manque).
• Comme les cartes font référence aux prototypes par leur identifiant, vous pouvez renommer, réorganiser ou compléter une bibliothèque sans risque. Un prototype absent de la bibliothèque est ignoré par le composant de rendu de la végétation, et le gestionnaire de décors l’affiche sous la forme d’un cube magenta de substitution ; ajouter un prototype portant le même identifiant le fait réapparaître. Pour le cheminement, les arbres dont le prototype manque ne sont pas dessinés, mais continuent de bloquer un cercle de rayon PathingMapBuilder.DefaultTreeFootprintRadius (0.8 m) × leur échelle. Les substituts de décor n’inscrivent aucune emprise dans la carte de cheminement tant que le prototype n’est pas revenu.
• Chaque instance possède un id unique et stable au sein de la carte. Obtenez de nouveaux identifiants avec map.AllocateInstanceId().
• Les positions sont locales à la carte. Les rotations suivent partout la même convention : en degrés, dans le sens horaire vu de dessus, 0 = +Z, 90 = +X (comme la rotation Y de Unity).

La convention position.y

Ne copiez jamais le yOffset du prototype dans position.y : il est ajouté au moment du rendu. DecorMath.ComputeLocalPosition et DecorMath.ToStoredHeight convertissent les positions stockées en positions de rendu, et inversement.

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

Carte de cheminement

La carte de cheminement répond aux questions « Une unité peut-elle marcher ici, un bâtiment peut-il y être placé ? ». C’est une grille de cellules de cheminement (PathingResolution par côté de cellule de carte, 2 par défaut, soit des cellules de cheminement de 1 m sur une carte à cellules de 2 m), chacune portant un octet PathingFlags. Elle est dérivée automatiquement et reconstruite de façon incrémentale dès qu’une de ses données d’entrée change (géométrie, eau, calques de sol, arbres, décors, surcharges). Elle n’est jamais enregistrée : seules les surcharges manuelles le sont.

Comment les indicateurs sont dérivés

1. Terrain : les parois de falaise (ainsi que la marge Cliff Margin) activent Cliff ; les pentes supérieures à Max Walkable Slope (42° par défaut) activent Steep ; l’eau active ShallowWater ou DeepWater selon sa profondeur ; Flyable est activé partout ; Buildable = praticable, pente ≤ Max Buildable Slope (18° par défaut) et au sec (ou en eau peu profonde quand Shallow Water Buildable est activé). Ensuite, le Pathing Effect du calque de sol dominant est appliqué (par exemple « Unbuildable » sur de la roche accidentée).
2. Emprises : les arbres bloquent un cercle (Footprint Radius × échelle de l’arbre × Tree Footprint Scale) ; les décors appliquent leur Footprint Effect dans un cercle ou dans un rectangle pivoté, sauf si l’instance possède DecorFlags.IgnorePathing.
3. Les surcharges manuelles, peintes avec les outils Paint Pathing / Clear Pathing, sont appliquées en dernier.

Les paramètres de ces règles se trouvent sur le composant RTSTerrain (RTSPathingSettings, propriété terrain.PathingSettings).

Les mêmes indicateurs PathingOverride servent aux effets de cheminement des calques de sol, aux effets d’emprise des décors et aux surcharges peintes. Interrogez le résultat avec terrain.GetPathing(world), terrain.IsWalkable(world) et terrain.IsBuildable(world), ou lisez directement terrain.Pathing.Flags.

Régions, positions de départ et marqueurs

Ce sont des objets légers destinés à la logique de votre jeu. Ils ne sont pas affichés en jeu ; les éditeurs les dessinent sous forme de gizmos.

Les outils stockent position.y = 0 pour les positions de départ et les marqueurs, et le traitent comme un décalage au-dessus du sol, comme pour les arbres.

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

Informations de la carte et environnement

EnvironmentSettings stocke l’éclairage d’une carte. Il est appliqué à la scène par un composant RTSEnvironment (GameObject ▸ RTS Terrain Studio ▸ Environment) ; sans ce composant, les valeurs sont enregistrées mais pas utilisées.

Notifications de modification

Lorsque vous modifiez MapData par le code, indiquez au terrain ce qui a changé et où, en cellules :

• terrain.NotifyChanged(MapLayers layers, RectInt cellRect) déclenche immédiatement MapChanged et met la reconstruction en file d’attente.
• terrain.NotifyChangedAll(layers) marque toute la carte comme modifiée (après une génération ou un import).
• Les modifications en attente sont traitées dans LateUpdate (et à chaque tick de l’éditeur hors Play Mode), ou immédiatement avec terrain.ProcessPendingChanges(). Ensuite, l’événement ChangesProcessed est déclenché : les meshes, les textures et le cheminement sont à jour.
• Un vertex touche jusqu’à quatre cellules. Convertissez un rectangle de vertices avec BrushUtility.VertexRectToCellRect(map, vertexRect), et les rectangles de texels avec 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);
    }
}

Coordonnées et terrains multiples

Toutes les données de la carte sont stockées dans l’espace local de la carte. Le Transform du GameObject RTSTerrain place cet espace dans le monde.

Espace local de la carte

• L’origine est le vertex (0, 0), c’est-à-dire le coin de la cellule (0, 0). X et Z vont de 0 à map.WorldSize en mètres, Y pointe vers le haut.
• Le vertex (x, z) se trouve à la position locale (x × CellSize, height, z × CellSize) ; le centre de la cellule (x, z) se trouve à ((x + 0.5) × CellSize, …, (z + 0.5) × CellSize).
• Y local = 0 correspond au niveau 0 avec une hauteur fine de 0. Sur une nouvelle carte de niveau de base 2 avec des niveaux de 2 m, le sol se trouve à Y local = 4 m.
• Les GameObjects des chunks se trouvent sous un enfant masqué du terrain nommé RTS Chunks (RTSTerrain.ChunkRoot). Cette racine n’a ni décalage local ni rotation et compense l’échelle du terrain, et la transformation locale de chaque chunk est l’identité : l’espace objet des meshes de chunk est donc l’espace local de la carte. C’est important à savoir lorsque vous écrivez des shaders pour le terrain.

Conversion entre l’espace monde et l’espace de la carte

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

Règles de position, de rotation et d’échelle

Terrains multiples

Une scène peut contenir autant de composants RTSTerrain que vous le souhaitez. Chacun possède sa propre carte, son propre tileset, ses bibliothèques, ses chunks et sa carte de cheminement.

• RTSTerrain.All liste tous les terrains activés ; RTSTerrain.Main renvoie le premier (pratique pour les jeux à carte unique ; les terrains d’aperçu temporaires sont ignorés).
• RTSTerrain.FindAt(worldPosition) renvoie le terrain dont la zone XZ contient une position donnée.
• RTSTerrain.RaycastAll(ray, out hit) effectue un raycast sur tous les terrains et renvoie l’impact le plus proche (hit.terrain indique le terrain touché).
• RTSTerrain.TerrainEnabled / TerrainDisabled sont des événements statiques destinés aux systèmes qui suivent les terrains.
• Les terrains sont indépendants : les cartes ne sont pas raccordées à leurs bordures, et la recherche de chemin (RTSPathfinder.FindPath(terrain, …)) ne porte que sur un terrain à la fois. Pour que deux cartes se rejoignent sans raccord visible, donnez les mêmes hauteurs à leurs vertices de bordure.

using RTSTerrainStudio;
using UnityEngine;

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

Assets de carte et fichiers de carte

Une carte est enregistrée sous forme de fichier .rtsmap. Le même format binaire sert dans l’éditeur Unity (comme asset de votre projet) et dans l’éditeur en jeu (comme fichier sur le disque) : les cartes créées par les joueurs peuvent donc être ouvertes dans Unity, et inversement.

Fichiers .rtsmap dans le projet

Lorsque Unity trouve un fichier .rtsmap dans le dossier Assets, l’importeur RTSMapImporter le convertit en RTSMapAsset. L’asset stocke les octets compressés du fichier, un petit en-tête (nom, auteur, taille, joueurs, identifiant du tileset) et un aperçu de la mini-carte, qui sert aussi de miniature dans la fenêtre Project.

Créer un asset de carte

• Tools ▸ RTS Terrain Studio ▸ New Map Wizard... : configuration guidée (informations de base, taille, apparence, terrain) ; écrit le fichier et crée un terrain associé, ou l’assigne au terrain sélectionné.
• Assets ▸ Create ▸ RTS Terrain Studio ▸ Map (.rtsmap) : crée dans le dossier sélectionné une carte plate de 128 × 128 avec les paramètres par défaut.
• Save As… dans la fenêtre RTS Terrain Studio : écrit la carte actuelle d’un terrain dans un nouveau fichier.
• Copiez dans le dossier Assets un fichier .rtsmap créé avec l’éditeur en jeu ; il est importé comme n’importe quel autre fichier.

L’Inspector d’un asset de carte

Sélectionnez un asset de carte pour afficher son aperçu, son nom, son auteur, sa description, sa taille, son nombre de joueurs, son tileset et sa version de format, ainsi que des statistiques (cellules, taille réelle, taille de cellule, hauteur de niveau, positions de départ, arbres, décors, régions, marqueurs, couches de détails, taille du fichier, mémoire, dernière modification).

L’aperçu est précalculé de nouveau automatiquement lorsque le tileset portant l’identifiant de la carte est ajouté ou supprimé, ou que ses couleurs de mini-carte changent. Reconstruire les tableaux de textures ne réimporte pas les cartes. Un fichier endommagé est importé comme asset vide, avec une icône d’erreur et une erreur d’importation dans la fenêtre Console.

Édition, Save et Save As

Assignez un asset de carte au champ Map Asset d’un RTSTerrain. Lorsque le terrain est activé, il charge la carte en mémoire, et toutes les modifications portent sur cette copie en mémoire. Le fichier de scène ne stocke que la référence à l’asset, jamais les données de la carte elles-mêmes.

• Save (dans l’en-tête de la fenêtre RTS Terrain Studio, ou Save Map dans le menu d’options de l’overlay RTS Terrain Studio de la Scene View) réécrit la carte dans son fichier .rtsmap et la réimporte. Le bouton Save est mis en évidence tant qu’il reste des modifications non enregistrées.
• Save As… écrit un nouveau fichier et l’assigne au terrain sans recharger la carte : votre historique d’annulation est donc conservé.
• Open… charge un autre asset de carte ; Reload recharge la carte depuis son asset et abandonne les modifications non enregistrées.
• Un terrain sans asset de carte crée une carte à partir de ses Default Map Settings. Cette carte n’existe qu’en mémoire tant que vous n’avez pas utilisé Save As.
• Enregistrer la scène (Ctrl+S) enregistre aussi les cartes modifiées des terrains de cette scène, et propose Save As pour les nouvelles cartes qui n’ont pas encore de fichier. Ces deux comportements peuvent être désactivés dans le menu d’options de l’overlay de la Scene View (Save Maps When Saving the Scene, Offer Save As for New Maps).
• Si vous entrez en Play Mode, fermez une scène ou quittez Unity alors que des modifications de carte ne sont pas enregistrées, une invite vous demande d’abord si vous voulez les enregistrer. Pour les modifications effectuées en Play Mode (outils de la Scene View ou éditeur en jeu), l’enregistrement vous est également proposé lorsque vous quittez le Play Mode.

Fichiers de carte à l’exécution

Dans le build d’un jeu, les cartes sont de simples fichiers sur le disque :

• RTSMapSerializer.DefaultMapsFolder est le dossier Maps situé dans RTSMapSerializer.StorageRoot, qui vaut Application.persistentDataPath, si bien que sous Windows, ce dossier est en général %USERPROFILE%\AppData\LocalLow\<Company>\<Product>\Maps. Dans les builds Web, StorageRoot est un dossier situé dans le stockage du navigateur (voir Les cartes dans le navigateur).
• L’éditeur en jeu (RTSRuntimeEditor) enregistre et ouvre les cartes dans le dossier défini par son champ Maps Folder (vide = le dossier par défaut ci-dessus ; les chemins relatifs sont résolus par rapport à RTSMapSerializer.StorageRoot). Lorsque Write Preview Images est activé, il écrit à côté de chaque carte enregistrée une petite image de mini-carte Name.preview.png, destinée à son explorateur de cartes.
• Pour partager une carte, copiez le fichier .rtsmap dans le dossier des cartes d’un autre joueur, ou dans un projet Unity. Dans un navigateur web, utilisez plutôt les commandes Download Map et Import Map de l’éditeur en jeu.
• Les cartes que vous livrez avec le jeu peuvent tout simplement être des assets de carte référencés par un terrain ou un script ; elles sont incluses dans le build comme n’importe quel autre asset.

using System.IO;
using RTSTerrainStudio;
using UnityEngine;

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

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

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

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

Tilesets

Un tileset (RTSTileset) définit l’apparence d’une carte : jusqu’à 16 calques de sol, jusqu’à 4 calques de falaise et le style de l’eau, à la manière des tilesets été, hiver ou désert des éditeurs de cartes des RTS classiques. Vous pouvez avoir autant de tilesets que vous le souhaitez et changer à tout moment le tileset d’un terrain : les cartes peintes ne stockent que des indices de calques, si bien que la même carte peut s’afficher en version été comme en version hiver.

1. Créez un tileset avec Assets ▸ Create ▸ RTS Terrain Studio ▸ Tileset.
2. Faites glisser vos textures de sol sur la section Ground Layers de l’Inspector. Un calque est créé par texture d’albédo. Les normal maps et textures de hauteur correspondantes sont détectées grâce au suffixe de leur nom de fichier (par exemple _n, _normal, _nrm, _normalgl, _h, _height, _disp) ; les textures de rugosité, d’AO et de métallicité sont ignorées, vous pouvez donc déposer tout un dossier de textures téléchargé.
3. Ajoutez de la même façon des calques de falaise dans Cliff Layers.
4. Assignez le tileset au champ Tileset de votre RTSTerrain.
5. Cliquez une fois sur Build Texture Arrays dans la section Texture Arrays (voir Tableaux de textures).

Champs du tileset

Champs des calques de sol

Champs des calques de falaise

Les parois de falaise sont texturées par projection triplanaire dans l’espace local de la carte : les textures de falaise ne nécessitent donc aucune disposition UV particulière.

Profil d’eau

Le profil d’eau fait partie du tileset ; il est utilisé par le rendu de l’eau, la carte de cheminement et la mini-carte.

Modifier les tilesets par le code

Les tilesets sont des ScriptableObjects. Après avoir modifié des champs par le code, appelez tileset.NotifyChanged() pour que les terrains actualisent leurs matériaux. tileset.GetGroundLayer(index) et GetCliffLayer(index) renvoient null pour les emplacements inutilisés.

Tableaux de textures

Le shader de terrain dessine les 20 calques en une seule passe : toutes les textures de calques sont donc regroupées dans deux tableaux de textures GPU. Vous ne créez jamais ces tableaux vous-même : vous fournissez des textures Unity ordinaires, de n’importe quelle taille et de n’importe quel format, et les tableaux sont générés à partir d’elles.

Structure

• La première tranche de falaise est RTSTileset.CliffSliceOffset (16) ; le nombre total de tranches est RTSTileset.TotalSlices (20).
• La hauteur (alpha) provient de la texture Height Map du calque (canal R) ; à défaut, de l’alpha de l’albédo si Height From Albedo Alpha est activé ; sinon, c’est une valeur constante de 0.5.
• Les normales sont décodées pendant la génération : vos normal maps peuvent donc utiliser comme d’habitude l’importation de normal maps de Unity (DXT5nm / BC5). Les calques sans normal map reçoivent une normale plate.
• Les calques sans albédo reçoivent une tranche gris neutre avec un motif discret ; le shader applique tout de même la teinte.
• Chaque tranche possède une chaîne de mips complète et utilise le filtrage trilinéaire. Les sources de toute taille sont redimensionnées selon le paramètre Resolution choisi.

Tableaux générés et repli à l’exécution

Les tableaux peuvent voir le jour de deux manières :

La section Texture Arrays affiche un badge d’état :

• Not built : le terrain utilise des tableaux créés à l’exécution. Cliquez une fois sur Build Texture Arrays.
• Up to date : le format, la taille, le nombre de mips et la mémoire utilisée sont affichés.
• Outdated : les textures, la résolution ou la compression ont changé, ou les tableaux ont été générés pour une autre plateforme ou une autre compression de textures. Générez-les de nouveau, ou laissez le prochain build de joueur s’en charger.
• Building : une génération est en cours ou planifiée.

La section indique aussi le format cible pour la plateforme de build active, ainsi que la taille et la durée de génération estimées, et demande une confirmation avant toute génération de plus de 256 Mo. Clear supprime les tableaux générés.

Builds de joueur

Les builds de joueur utilisent les tableaux générés tels quels, car seul l’éditeur peut les comparer aux textures sources. Les tableaux obsolètes sont donc reconstruits automatiquement juste avant chaque build de joueur, et les tilesets dont les tableaux n’ont jamais été générés continuent d’utiliser des tableaux créés à l’exécution. Les détails, notamment le mode batch et -rtsAllowOutdatedTextureArrays, sont décrits dans Tableaux de textures dans les builds de joueur. Les builds de joueur libèrent aussi la copie CPU des tableaux générés dès leur première utilisation, ce qui économise à peu près autant de mémoire que les tableaux en occupent sur le GPU.

Par le code : tileset.HasValidBuiltArrays indique si les tableaux compressés seront utilisés. Dans l’éditeur, ils doivent exister et correspondre à ComputeContentHash(). Un build de joueur considère les tableaux générés comme valides jusqu’à ce que votre code modifie à l’exécution les textures des calques, la résolution ou la compression ; il se replie alors sur des tableaux créés à l’exécution. Les valeurs de ComputeContentHash() ne sont comparables qu’au sein de l’éditeur ou au cours d’une même exécution d’un build de joueur, car l’éditeur calcule le hachage à partir de l’état d’importation des textures. Lorsque HasValidBuiltArrays vaut false, RTSTerrain crée des tableaux non compressés à l’exécution (RTSTextureArrayBuilder.Acquire). tileset.BuiltAlbedoArray / BuiltNormalArray donnent accès aux tableaux générés. Dans votre propre code d’exécution, utilisez RTSShaderReferences.FindShader(name) (et FindMaterial(name)) au lieu de Shader.Find, pour que la recherche fonctionne aussi dans les builds de joueur.

Auto Build

Lorsque Auto Build est activé (c’est le cas par défaut ; il s’agit d’une préférence de l’éditeur commune à tous les tilesets), les tableaux qui ont déjà été générés sont reconstruits une seconde après toute modification des textures, de la résolution ou de la compression, avec une compression rapide. La première génération se lance toujours manuellement. Une génération automatique annulée ou en échec n’est pas relancée tant que le contenu ou le format cible ne change pas. Le bouton Build Texture Arrays, lui, utilise la qualité de compression normale, au rendu légèrement meilleur : cliquez dessus avant de publier votre jeu.

Bibliothèque de végétation

Une bibliothèque de végétation (RTSVegetationLibrary) répertorie l’herbe, les plantes et les arbres disponibles pour la peinture. Créez-en une avec Assets ▸ Create ▸ RTS Terrain Studio ▸ Vegetation Library et assignez-la au champ Vegetation Library du RTSTerrain. Pour afficher la végétation, le terrain a aussi besoin d’un composant RTSVegetationRenderer (l’Inspector de RTSTerrain propose de l’ajouter).

L’Inspector comporte deux onglets, Details et Trees, avec une grille de miniatures. Déposez-y des prefabs (arbres), des textures (quads d’herbe) ou des meshes (meshes de détail) pour ajouter des entrées. Chaque entrée reçoit un id stable, utilisé par les cartes ; les entrées dupliquées reçoivent automatiquement de nouveaux identifiants.

Prototypes de détails

Les détails sont de petites plantes présentes en grand nombre et peintes par densité (voir Densité de détails). Ils sont générés par blocs de 16 × 16 cellules et dessinés avec le shader procédural interne Hidden/RTS Terrain Studio/Detail, qui gère le vent, le brouillard de guerre et la variation de couleur.

Prototypes d’arbres

Les arbres sont des instances individuelles (voir Arbres et instances de décor), placées avec l’outil Place Trees.

Instanciation GPU

Les arbres instanciés sont dessinés par instanciation GPU : l’option Enable GPU Instancing de leurs matériaux devrait donc être activée. Si elle est désactivée sur un matériau, le renderer utilise automatiquement une copie cachée de ce matériau, avec l’instanciation activée (synchronisée avec l’original pendant vos modifications), et l’Inspector de la bibliothèque affiche un message d’information avec un bouton Enable qui corrige le matériau lui-même. Les matériaux des détails n’ont pas besoin de l’instanciation, car ils sont toujours dessinés avec le shader de détail procédural.

Par le code, vous supprimez une instance d’arbre avec RTSVegetationRenderer.RemoveTree(id) (par exemple lorsqu’un ouvrier récolte un arbre) et vous la trouvez avec TryFindNearestTree ; GetTreeObject(id) renvoie son GameObject ou son proxy de collider.

Modifier les bibliothèques par le code

Les cartes stockent une palette d’identifiants de prototypes. Pour retrouver le prototype qui correspond à un indice de palette, passez donc par la bibliothèque :

• Arbres : vegetationLibrary.FindTree(map.TreePrototypeIds[tree.prototype]).
• Couches de détails : vegetationLibrary.FindDetail(layer.prototypeId).
• Décors : decorLibrary.Find(map.DecorPrototypeIds[d.prototype]). Obtenez le prefab de la variante avec prototype.GetPrefab(d.variant) : 0 correspond au prefab principal, et les variantes invalides ou vides se rabattent sur celui-ci. VariantCount inclut le prefab principal.
• decorLibrary.GetCategories() liste les catégories dans l’ordre d’affichage (les prototypes sans catégorie sont listés sous Misc).
• vegetationLibrary.EnsureUniqueIds() attribue de nouveaux identifiants aux entrées dupliquées.

Après avoir modifié une bibliothèque par le code, appelez library.NotifyChanged() (cette méthode déclenche l’événement Changed de la bibliothèque) : RTSTerrain déclenche alors LibrariesChanged et les renderers s’actualisent. La règle est la même que pour les tilesets.

Bibliothèque de décors

Une bibliothèque de décors (RTSDecorLibrary) liste les accessoires (doodads) que vous pouvez placer : rochers, ruines, clôtures, caisses, bâtiments ou tout autre prefab. Créez-en une avec Assets ▸ Create ▸ RTS Terrain Studio ▸ Decor Library et assignez-la au champ Decor Library du composant RTSTerrain. Un composant RTSDecorManager placé sur le terrain maintient la scène synchronisée avec les instances placées.

L’Inspector affiche les prototypes sous forme de grille, avec des miniatures générées automatiquement et un onglet par catégorie (plus All). Déposez-y des prefabs pour les ajouter à la catégorie actuelle ; cliquez avec le bouton droit sur l’onglet d’une catégorie pour le renommer. Les prototypes sans catégorie apparaissent sous Misc.

Champs des prototypes de décor

Emprises

• Une emprise circulaire utilise la valeur X de Footprint Size comme rayon, multipliée par la plus grande échelle horizontale de l’instance.
• Une emprise rectangulaire suit la rotation de l’instance (ses axes X et Z projetés sur le sol) et son échelle X/Z : un mur pivoté bloque ainsi exactement sa propre surface.
• Aucune emprise n’est écrite lorsque la forme vaut None, que l’effet vaut None ou que l’instance porte l’indicateur DecorFlags.IgnorePathing.
• Utilisez Unbuildable seul pour les décorations plates sur lesquelles les unités peuvent marcher (fleurs, gravats), et Unwalkable pour les objets solides.

Modes d’apparition

Les décors instanciés se comportent comme les arbres instanciés vis-à-vis de l’instanciation GPU : les matériaux sans Enable GPU Instancing sont dessinés au moyen d’une copie masquée du matériau, avec l’instanciation activée. Les objets créés sont réutilisés via un pool ; RTSDecorManager.GetInstanceObject(id) renvoie l’objet créé pour une instance, et RTSDecorInstance.FromCollider(collider) retrouve l’instance qui correspond à un impact physique.

Le format de fichier .rtsmap

Cette section s’adresse aux programmeurs qui veulent lire des cartes avec d’autres outils, écrire des convertisseurs ou ajouter leurs propres données. Vous n’en avez pas besoin pour utiliser le package : RTSMapSerializer s’occupe de tout.

Structure binaire

Tous les nombres sont en little-endian. Les chaînes utilisent le format BinaryWriter de .NET : une longueur encodée en 7 bits, suivie des octets UTF-8.

L’en-tête n’est pas compressé, ce qui permet aux explorateurs de cartes d’afficher le nom, l’auteur, la taille et le nombre de joueurs sans décompresser la carte (RTSMapSerializer.TryReadHeader, TryReadHeaderFromFile, structure RTSMapHeader). Les lecteurs utilisent la longueur de l’en-tête pour sauter directement à sa fin : les versions futures peuvent ainsi ajouter des champs à l’en-tête.

Sections

Chaque section a la forme [int32 tag][int32 length][payload]. Les étiquettes sont des codes FourCC stockés en little-endian : le premier caractère se trouve donc dans l’octet de poids faible (DIMS = 0x534D4944). Les tableaux de données raster sont écrits sous la forme d’un nombre d’éléments en int32, suivi des éléments bruts.

Les « properties » sont écrites sous la forme d’un nombre en int32, suivi de paires de chaînes clé/valeur. La carte de cheminement dérivée n’est pas stockée ; seules les surcharges manuelles le sont.

Sections inconnues, fichiers endommagés et gestion des versions

• Les sections inconnues sont ignorées grâce à leur longueur. Les anciennes versions du package peuvent donc lire des fichiers plus récents qui contiennent des sections supplémentaires, et vos sections personnalisées ne perturbent jamais les autres lecteurs.
• Si la version de format d’un fichier est plus récente que celle du lecteur, un avertissement est consigné et le fichier est tout de même lu ; les données inconnues sont ignorées.
• Si le nombre d’éléments d’une couche raster ne correspond pas à la taille de la carte, un avertissement est consigné ; ce qui tient dans la carte est lu, le reste est ignoré.
• Les fichiers tronqués ou endommagés déclenchent toujours le même type d’exception, System.IO.InvalidDataException. Un fichier dont le nombre magique est incorrect est signalé par le message « Not an RTS Terrain Studio map file ».
• RTSMapSerializer.SaveToFile écrit d’abord dans <path>.tmp, puis remplace le fichier : un plantage pendant l’enregistrement ne laisse donc jamais une carte à moitié écrite.
• Règle de compatibilité du format : les nouvelles données sont ajoutées sous forme de nouvelles sections ou de champs ajoutés à la fin de l’en-tête, jamais en modifiant des sections existantes. Faites de même avec vos propres sections et conservez un numéro de version dans votre charge utile.

Sections personnalisées

Vous pouvez stocker vos propres données dans les fichiers de carte, par exemple des règles de jeu, des déclencheurs ou des données de quête. Deux hooks statiques de RTSMapSerializer le permettent :

• Choisissez des étiquettes qui n’entrent pas en conflit avec les étiquettes intégrées ; faites-les commencer par X (par exemple XGLD). N’utilisez jamais 0, qui marque la fin des sections.
• Les deux hooks sont de simples délégués : combinez des gestionnaires avec += et retirez-les avec -=, ce qui permet à plusieurs systèmes d’ajouter des sections.
• Dans votre lecteur, vérifiez l’étiquette et ignorez les sections qui ne vous appartiennent pas.
• MapData ne prévoit pas d’emplacement pour vos données. Conservez-les à côté de la carte (l’exemple utilise une ConditionalWeakTable). Les données conservées de cette façon ne sont pas copiées par MapData.Clone() ni par ResizeMap, et ne sont pas enregistrées dans l’historique d’annulation.
• Inscrivez les hooks avant le chargement ou l’enregistrement de la moindre carte. Dans l’éditeur Unity, les cartes sont aussi lues par l’importateur et écrites par la commande Save : inscrivez-les donc aussi pour l’éditeur (l’exemple utilise 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();
        }
    }
}

Dans le code du jeu, lisez la valeur avec StartingGoldSection.Get(terrain.Map).startingGold. Après avoir modifié la valeur dans l’éditeur, marquez la carte comme modifiée (par exemple terrain.NotifyChanged(MapLayers.Info, terrain.Map.CellBounds), ou définissez terrain.HasUnsavedChanges = true) pour qu’elle soit enregistrée.

La fenêtre RTS Terrain Studio

La fenêtre est le centre de contrôle de l’éditeur. Elle ne possède aucun état d’édition propre : elle affiche et modifie la session d’édition partagée, que la Scene View, l’overlay de la Scene View et l’Inspector du composant RTS Terrain utilisent aussi. Tout ce que vous changez à un endroit se répercute immédiatement dans les autres.

Vous pouvez l’ouvrir de plusieurs façons :

• Tools ▸ RTS Terrain Studio ▸ Editor Window
• le bouton Open RTS Terrain Studio de l’Inspector du composant RTS Terrain
• le bouton d’ouverture de la fenêtre dans l’overlay RTS Terrain Studio de la Scene View

La fenêtre comporte quatre zones : l’en-tête en haut, la barre d’onglets, la page défilante et la barre d’état en bas.

Pages d’outils

Chaque onglet de catégorie affiche une pile de panneaux. Vous pouvez replier chaque panneau en cliquant sur son en-tête.

Panneau	Contenu
Category Tools	La grille d’outils. Cliquez sur un outil pour peindre avec lui dans la Scene View. Cliquez à nouveau sur l’outil actif pour arrêter l’édition. Survolez un outil pour lire sa description et ses touches de modification. Les outils personnalisés que vous écrivez apparaissent ici automatiquement.
Panneau de l’outil	Le nom, la description et l’indication de l’outil sélectionné, un bouton ? qui ouvre la section correspondante de ce manuel, et une ligne d’état en direct. Placez la souris sur le terrain pour la voir, par exemple Ground 4.25 m | Fine +0.25 m | Level 2 pour les outils de hauteur ou Level 2 → 3 pour les outils de falaise.
Getting Started	Affiché lorsqu’aucun outil de cette catégorie n’est sélectionné. Si vous peignez avec un outil d’une autre catégorie, il indique Active tool: X et propose Go to Tool.
Brush	Forme, rayon, intensité, dureté, courbe d’atténuation, rotation, rotation aléatoire, espacement et décalage aléatoire. Ces paramètres sont partagés par tous les outils pinceaux. Masqué pour les outils qui n’utilisent pas le pinceau. Voir Pinceaux.
Symmetry	Mode et centre de symétrie (non affiché pour les outils à glissement). Voir Symétrie.
Tool Settings	Les paramètres de l’outil sélectionné, générés automatiquement à partir du code de l’outil. Ils sont mémorisés d’une session de l’éditeur à l’autre. Les tableaux de la référence des outils détaillent chaque paramètre.
Actions de catégorie	Panneaux supplémentaires pour certaines catégories : Auto Paint Whole Map (Paint), Selection (Decor, lorsque Select Decor est actif), Water at Cursor (Water) et Pathing Overlay (Pathing).

Lorsque l’édition est en pause, un bandeau affiche Editing is paused – the Scene View uses Unity's tools. Son bouton Resume réactive l’édition.

Onglet Map

L’onglet Map regroupe les paramètres et les opérations qui portent sur toute la carte. Chaque modification peut être annulée, sauf si sa boîte de dialogue indique le contraire. Le bouton ? en haut ouvre cette section.

Onglet Settings

Peindre dans la Scene View

Toute l’édition se fait dans la Scene View. Lorsque l’édition du terrain est activée et qu’un outil est sélectionné, le bouton gauche de la souris peint avec l’outil au lieu de sélectionner des objets. Activez l’édition avec le bouton Editing de la fenêtre, le bouton Start Editing de l’overlay, le bouton Edit Terrain de l’Inspector, ou en cliquant sur un outil. Désactivez-la avec 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 ...
        }
    }
}

Raccourcis clavier

Les raccourcis de la Scene View sont enregistrés dans le Shortcut Manager de Unity, dans la catégorie RTS Terrain Studio. Ils ne sont actifs que si l’édition du terrain est activée, si une Scene View ou l’une des fenêtres d’éditeur de RTS Terrain Studio a le focus clavier (ou si la souris survole une Scene View), et si vous n’êtes pas en train de saisir du texte ou un nombre dans un champ. Hors édition, des touches comme R ou les touches numériques conservent leur rôle habituel dans Unity.

Les touches et actions de la souris suivantes sont gérées par le package lui-même et ne peuvent pas être réaffectées :

Les touches suivantes sont des raccourcis et des commandes propres à Unity. RTS Terrain Studio y réagit, mais elles suivent les affectations que vous leur donnez dans Edit ▸ Shortcuts..., sous les catégories de Unity (Main Menu/Edit, Tools) :

R avec Select Decor correspond à l’entrée RTS Terrain Studio/Toggle Random Rotation propre au package : tant que Select Decor est actif, elle passe à l’outil Scale de Unity au lieu d’activer ou de désactiver la rotation aléatoire.

Pinceaux

Tous les outils pinceaux partagent un même pinceau. Vous le réglez dans le panneau Brush de n’importe quelle page d’outil, dans l’overlay (Size et Strength) ou avec les raccourcis. Le pinceau est mémorisé d’une session de l’éditeur à l’autre.

Symétrie

La symétrie répète chaque empreinte, chaque clic et chaque objet placé à des positions obtenues par réflexion ou par rotation. C’est ainsi que vous construisez des cartes compétitives équitables : chaque joueur reçoit les mêmes collines, falaises, rampes, arbres et mines d’or. Choisissez le mode dans le panneau Symmetry ou dans l’overlay. Des repères magenta dans la Scene View montrent les axes et le centre.

Centre est le centre de symétrie en coordonnées de carte normalisées : (0.5, 0.5) correspond au centre de la carte et constitue la valeur par défaut. Reset l’y ramène. Si vous déplacez le centre, certaines copies peuvent tomber hors de la carte et sont alors ignorées ; le panneau affiche un avertissement.

Annuler et rétablir

Chaque modification du terrain est enregistrée dans l’historique d’annulation propre à la carte, qui est lié au système d’annulation de Unity. Ctrl+Z, Ctrl+Y et le menu Edit ▸ Undo fonctionnent pour les modifications du terrain exactement comme pour n’importe quelle autre modification, et le menu Edit affiche le nom de l’étape, par exemple Undo Raise / Lower. Les boutons Undo et Redo de l’en-tête de la fenêtre font de même et maintiennent l’historique de Unity synchronisé. Annuler entre-temps une modification d’un autre objet ne perturbe pas l’historique du terrain.

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

Référence des outils

Les sections suivantes décrivent chaque outil des huit catégories. Tous les outils fonctionnent de la même façon dans l’éditeur Unity et dans l’éditeur en jeu. Quelques conventions s’appliquent à tous :

• Id est l’identifiant unique de l’outil. Utilisez-le dans le code, par exemple RTSEditorContext.ActivateTool("height.raise").
• Saisie : les outils Pinceau peignent pendant que vous faites glisser la souris. Les outils Clic agissent une fois par clic. Les outils Glisser s’utilisent en appuyant, en faisant glisser puis en relâchant (rectangles, sélection par rectangle).
• Répétition : nombre d’empreintes par seconde tant que vous maintenez le bouton enfoncé sans bouger la souris.
• Shift inverse l’effet et Ctrl+clic prélève une valeur, lorsque le tableau l’indique.
• Chaque paramètre est indiqué avec sa plage et sa valeur par défaut. Les paramètres sont conservés d’une session de l’éditeur à l’autre. Le bouton Reset All Tool Settings de l’onglet Settings rétablit les valeurs par défaut.

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

Outils de hauteur

Les outils de hauteur sculptent la hauteur fine : collines, vallées, routes et détails naturels par-dessus les niveaux de falaise. Ils ne modifient jamais les niveaux de falaise, si bien que les parois de falaise restent nettes. La ligne d’état affiche la hauteur du sol, la hauteur fine et le niveau de falaise sous le curseur.

Paramètres de l’outil Raise / Lower

Paramètres de l’outil Smooth

Paramètres de l’outil Flatten

Paramètres de l’outil Set Height

Paramètres de l’outil Noise

Paramètres de l’outil Terrace

Paramètres de l’outil Erode

Outils de falaise

Les outils de falaise modifient le niveau de falaise des vertices (0–15) et l’aspect des parois de falaise entre les niveaux. Le pinceau s’aligne sur les vertices et agit comme une sélection franche : vous peignez des vertices entiers, jamais des demi-niveaux. La ligne d’état affiche le niveau survolé et le niveau que vous vous apprêtez à peindre, par exemple Level 2 → 3.

Paramètres de l’outil Raise / Lower Level

Le niveau cible est déterminé à partir du vertex situé sous le curseur au début du trait : un niveau au-dessus (ou au-dessous avec Shift). En faisant glisser, vous peignez ce même niveau, ce qui vous permet d’étendre un plateau sans empiler les niveaux. L’outil ne fait qu’élever (ou qu’abaisser) les vertices.

Paramètres de l’outil Set Level

Outil Ramp

L’outil Ramp n’a aucun paramètre. Une cellule devient une rampe lorsque ses quatre vertices de coin portent l’indicateur de rampe et que la différence de niveau qu’elle couvre est d’exactement un niveau. La ligne d’état vous aide : elle compte les cellules de rampe valides sous le pinceau, signale les cellules portant l’indicateur mais sans différence de niveau, et vous avertit lorsqu’une rampe couvre plus d’un niveau (elle serait étirée).

Paramètres de l’outil Cliff Type

Paramètres de l’outil Clean Cliffs

Bords de falaise automatiques

Dans les éditeurs de cartes des RTS classiques, élever une falaise modifie aussi le sol voisin. Les outils de falaise font de même : à la fin d’un trait, le sol situé le long de chaque nouveau bord de falaise est peint avec le calque de sol choisi dans le paramètre Edge Ground Layer du type de falaise, par exemple un rebord pierreux « Rocky Dirt ». Le rebord suit le contour arrondi de la falaise, s’estompe sur la largeur Edge Width et présente un contour légèrement irrégulier, ce qui lui donne un aspect naturel plutôt que découpé selon les cellules.

1. Sélectionnez le tileset et ouvrez Cliff Layers. Dans chaque panneau de falaise, choisissez un calque pour Edge Layer (les tilesets de démo utilisent Rocky Dirt).
2. Choisissez Raise / Lower Level, Set Level, Ramp ou Clean Cliffs, et laissez Paint Cliff Edges activé.
3. Peignez les falaises comme d’habitude. Le rebord apparaît lorsque vous relâchez le bouton de la souris.

• Une seule étape d’annulation : le changement de niveau et la peinture du bord sont annulés ensemble.
• Symétrie : toutes les copies symétriques reçoivent leurs bords lors de la même passe.
• Rampes : les cellules de rampe ne reçoivent jamais de rebord. Peindre une rampe en travers d’un bord y supprime le rebord lorsque Clean Up Old Edges est activé.
• Falaises déplacées : lorsque Clean Up Old Edges est activé, le rebord d’un bord qui a disparu (plateau abaissé, plateau étendu) est de nouveau supprimé. Le calque de bord est alors retiré même si vous l’aviez peint à la main à cet endroit.
• Facultatif : désactivez Paint Cliff Edges pour un outil, ou réglez le champ Edge Layer du type de falaise sur None pour tout le tileset. Si l’option est activée mais qu’aucun calque de bord n’est défini, la ligne d’état le signale.

Outils de peinture

Les outils de peinture peignent les calques de sol du tileset (jusqu’à 16). Chaque texel de splat stocke les poids de tous les calques, dont la somme fait toujours 100 %. Si le calque sélectionné n’existe pas dans le tileset ou n’a pas de texture, la ligne d’état le signale au lieu de peindre silencieusement avec une solution de repli.

Paramètres de l’outil Paint Layer

Paramètres de l’outil Tile Paint

Paramètres de l’outil Fill / Replace

Chaque clic constitue une seule étape d’annulation, qui n’enregistre que la zone réellement modifiée.

Paramètres de l’outil Smooth Paint

Paramètres de l’outil Auto Paint

L’onglet Paint affiche aussi le panneau Auto Paint Whole Map, qui repeint toute la carte à partir du profil en une seule étape.

Outils de végétation

Les outils de végétation peignent l’herbe et les petites plantes (détails) et placent des arbres à partir de la Vegetation Library du terrain. Si le terrain n’en a pas, la page de l’outil propose Create Vegetation Library. Choisissez des prototypes dans la grille ; si aucun n’est sélectionné, le premier prototype de la bibliothèque est utilisé.

Paramètres de l’outil Paint Details

Paramètres de l’outil Erase Details

Paramètres de l’outil Place Trees

Paramètres de l’outil Erase Trees

Outils de décor

Les outils de décor placent, effacent et modifient des accessoires tels que des rochers, des ruines et des clôtures, issus de l’asset Decor Library du terrain. Si le terrain n’en a pas, la page de l’outil propose le bouton Create Decor Library. La grille de prototypes dispose d’un champ de recherche et de filtres par catégorie.

Paramètres de l’outil Place Decor

Paramètres de l’outil Erase Decor

Paramètres de l’outil Select Decor

Panneau Selection

Lorsque l’outil Select Decor est actif, l’onglet Decor affiche le panneau Selection avec le nombre d’objets sélectionnés. Chaque bouton de modification (Delete, Duplicate, Snap to Ground, Rotate 90°, Lock, Unlock) constitue une seule étape d’annulation. Select All et Clear ne modifient que la sélection.

Le déplacement, la rotation et la mise à l’échelle avec les poignées sont décrits dans Poignées de la sélection de décors.

Outils d’eau

L’eau est stockée par vertex : un vertex est soit mouillé, avec une hauteur de surface de l’eau, soit sec. Comme les outils de falaise, les outils d’eau utilisent une sélection franche. Le panneau Water at Cursor affiche le niveau et la profondeur d’eau sous la souris, et indique s’il s’agit d’eau peu profonde (praticable) ou d’eau profonde, d’après la limite d’eau peu profonde du tileset.

Paramètres de hauteur d’eau (Paint Water et Flood Fill)

Paramètres de l’outil Paint Water

Paramètres de l’outil Flood Fill

Outils de cheminement

La carte de cheminement (praticable, constructible, survolable, eau) est déduite automatiquement des pentes, des falaises, de l’eau, des calques de sol, des arbres et des décors. Par-dessus, les outils de cheminement peignent des surcharges manuelles, avec une sélection franche par cellule de cheminement. Pour voir le résultat, activez la superposition dans le panneau Pathing Overlay ou avec P.

Paramètres de l’outil Paint Pathing

Couleurs de la superposition de cheminement

Les règles de la partie automatique (pentes maximales, marge de falaise, etc.) se définissent dans le composant RTS Terrain ; voir Pathing Rules.

Outils de marqueurs

Les outils de marqueurs ajoutent des informations de gameplay à la carte : les positions de départ des joueurs, des régions nommées pour les déclencheurs et des points nommés comme des positions de caméra. Les marqueurs sont affichés dans la Scene View tant qu’un outil de marqueurs est actif ou que l’option Show Markers est activée.

Paramètres de l’outil Start Locations

Paramètres de l’outil Regions

Les nouvelles régions reçoivent automatiquement un nom unique.

Paramètres de l’outil Markers

Peinture automatique (Auto Paint)

La peinture automatique applique les calques de sol d’après le relief du terrain : de l’herbe sur les zones plates, de la roche sur les pentes escarpées et le long des falaises, du sable sur le rivage, des plaques de terre fragmentées par du bruit. C’est le moyen le plus rapide de donner un aspect fini à une carte fraîchement sculptée ou générée. Vous pouvez ensuite l’affiner à la main.

Il existe trois façons de l’utiliser :

• l’outil pinceau Auto Paint de l’onglet Paint peint les règles à l’intérieur du pinceau et les mélange avec la peinture existante selon le poids et l’intensité du pinceau. Avec Shift, il peint à la place le calque de base, ce qui efface la peinture des règles ;
• le panneau Auto Paint Whole Map de l’onglet Paint repeint chaque texel de sol de la carte en une seule étape d’annulation. Il comporte un champ Profile et un bouton Create Profile ;
• le bouton Apply To Map dans l’Inspector du profil, ainsi que l’étape Paint du générateur.