using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Xml.Linq; using UnityEditor; using UnityEditor.AssetImporters; using UnityEngine; using UnityEngine.Assertions; using UnityEngine.Tilemaps; namespace SuperTiled2Unity.Editor { [ScriptedImporter(ImporterConstants.MapVersion, ImporterConstants.MapExtension, ImporterConstants.MapImportOrder)] public partial class TmxAssetImporter : TiledAssetImporter { public const string TilesAsObjectsSerializedName = nameof(m_TilesAsObjects); public const string SortingModeSerializedName = nameof(m_SortingMode); public const string CustomImporterClassNameSerializedName = nameof(m_CustomImporterClassName); private SuperMap m_MapComponent; private Grid m_GridComponent; private GlobalTileDatabase m_GlobalTileDatabase; private Dictionary m_TilePolygonDatabase; private int m_NextTileAsObjectId; private Dictionary m_ObjectsById; [SerializeField] private bool m_TilesAsObjects = false; public bool TilesAsObjects => m_TilesAsObjects; [SerializeField] private SortingMode m_SortingMode = SortingMode.Stacked; public SortingMode SortingMode => m_SortingMode; [SerializeField] private bool m_IsIsometric = false; public bool IsIsometric => m_IsIsometric; [SerializeField] private string m_CustomImporterClassName = string.Empty; [SerializeField] private List m_InternalTilesets; /// Returns the game object corresponding to a Tiled object ID. public GameObject GetObject(int targetId) { if (m_ObjectsById.TryGetValue(targetId, out var go)) { return go; } return null; } protected override void InternalOnImportAsset() { base.InternalOnImportAsset(); ImporterVersion = ImporterConstants.MapVersion; AddSuperAsset(); XDocument doc = XDocument.Load(assetPath); if (doc != null) { // Early out if Zstd compression is used. This simply isn't supported by Unity. if (doc.Descendants("data").Where(x => ((string)x.Attribute("compression")) == "zstd").Count() > 0) { ReportGenericError("Unity does not support Zstandard compression.\nSelect a different 'Tile Layer Format' in your map settings in Tiled and resave."); return; } var xMap = doc.Element("map"); ProcessMap(xMap); } DoPrefabReplacements(); DoCustomImporting(); // Were any import errors captured along the way? m_MapComponent.m_ImportErrors = ImportErrors; } private void ProcessMap(XElement xMap) { Assert.IsNotNull(xMap); Assert.IsNull(m_MapComponent); Assert.IsNull(m_GlobalTileDatabase); m_TilePolygonDatabase = new Dictionary(); RendererSorter.SortingMode = m_SortingMode; // Create our map and fill it out bool success = true; success = success && PrepareMainObject(); success = success && ProcessMapAttributes(xMap); success = success && ProcessGridObject(xMap); success = success && ProcessTilesetElements(xMap); if (success) { // Custom properties need to be in place before we process the map layers AddSuperCustomProperties(m_MapComponent.gameObject, xMap.Element("properties")); using (SuperImportContext.BeginIsTriggerOverride(m_MapComponent.gameObject)) { // Add layers to our grid object ProcessMapLayers(m_GridComponent.gameObject, xMap); PostProccessMapLayers(m_GridComponent.gameObject); } } } // The map object is our Main Asset - the prefab that is created in our scene when dragged into the hierarchy private bool PrepareMainObject() { var icon = SuperIcons.instance.m_TmxIcon; var goGrid = new GameObject("_MapMainObject"); SuperImportContext.AddObjectToAsset("_MapPrfab", goGrid, icon); SuperImportContext.SetMainObject(goGrid); m_MapComponent = goGrid.AddComponent(); return true; } private bool ProcessMapAttributes(XElement xMap) { m_MapComponent.name = Path.GetFileNameWithoutExtension(this.assetPath); m_MapComponent.m_Version = xMap.GetAttributeAs("version"); m_MapComponent.m_TiledVersion = xMap.GetAttributeAs("tiledversion"); m_MapComponent.m_Orientation = xMap.GetAttributeAs("orientation"); m_MapComponent.m_RenderOrder = xMap.GetAttributeAs("renderorder"); m_MapComponent.m_Width = xMap.GetAttributeAs("width"); m_MapComponent.m_Height = xMap.GetAttributeAs("height"); m_MapComponent.m_TileWidth = xMap.GetAttributeAs("tilewidth"); m_MapComponent.m_TileHeight = xMap.GetAttributeAs("tileheight"); m_MapComponent.m_HexSideLength = xMap.GetAttributeAs("hexsidelength"); m_MapComponent.m_StaggerAxis = xMap.GetAttributeAs("staggeraxis"); m_MapComponent.m_StaggerIndex = xMap.GetAttributeAs("staggerindex"); m_MapComponent.m_Infinite = xMap.GetAttributeAs("infinite"); m_MapComponent.m_BackgroundColor = xMap.GetAttributeAsColor("backgroundcolor", NamedColors.Gray); m_MapComponent.m_NextObjectId = xMap.GetAttributeAs("nextobjectid"); m_IsIsometric = m_MapComponent.m_Orientation == MapOrientation.Isometric; m_NextTileAsObjectId = m_MapComponent.m_NextObjectId; return true; } private bool ProcessGridObject(XElement xMap) { // Add the grid to the map var goGrid = new GameObject("Grid"); goGrid.transform.SetParent(m_MapComponent.gameObject.transform); m_GridComponent = goGrid.AddComponent(); // Grid cell size always has a z-value of 1 so that we can use custom axis sorting float sx = SuperImportContext.MakeScalar(m_MapComponent.m_TileWidth); float sy = SuperImportContext.MakeScalar(m_MapComponent.m_TileHeight); m_GridComponent.cellSize = new Vector3(sx, sy, 1); Vector3 tilemapOffset = new Vector3(0, 0, 0); switch (m_MapComponent.m_Orientation) { case MapOrientation.Isometric: m_GridComponent.cellLayout = GridLayout.CellLayout.Isometric; tilemapOffset = new Vector3(-sx * 0.5f, -sy, 0); break; case MapOrientation.Staggered: m_GridComponent.cellLayout = GridLayout.CellLayout.Isometric; if (m_MapComponent.m_StaggerAxis == StaggerAxis.Y) { if (m_MapComponent.m_StaggerIndex == StaggerIndex.Odd) { // Y - Odd tilemapOffset = new Vector3(0, -sy, 0); } else { // Y-Even tilemapOffset = new Vector3(sx * 0.5f, -sy, 0); } } else if (m_MapComponent.m_StaggerAxis == StaggerAxis.X) { // X-Ood if (m_MapComponent.m_StaggerIndex == StaggerIndex.Odd) { tilemapOffset = new Vector3(0, -sy, 0); } else { // X-Even tilemapOffset = new Vector3(0, -sy * 1.5f, 0); } } break; case MapOrientation.Hexagonal: if (m_MapComponent.m_StaggerAxis == StaggerAxis.Y) { // Pointy-top hex maps m_GridComponent.cellLayout = GridLayout.CellLayout.Hexagon; m_GridComponent.cellSwizzle = GridLayout.CellSwizzle.XYZ; if (m_MapComponent.m_StaggerIndex == StaggerIndex.Odd) { // Y-Odd tilemapOffset = new Vector3(0, -sy, 0); } else { // Y-Even tilemapOffset = new Vector3(0, -sy * 0.25f, 0); } } else if (m_MapComponent.m_StaggerAxis == StaggerAxis.X) { // Flat-top hex maps. Reverse x and y on size. m_GridComponent.cellLayout = GridLayout.CellLayout.Hexagon; m_GridComponent.cellSwizzle = GridLayout.CellSwizzle.YXZ; m_GridComponent.cellSize = new Vector3(sy, sx, 1); if (m_MapComponent.m_StaggerIndex == StaggerIndex.Odd) { // X-Odd tilemapOffset = new Vector3(-sx * 0.75f, -sy * 1.5f, 0); } else { // X-Even tilemapOffset = new Vector3(0, -sy * 1.5f, 0); } } break; default: m_GridComponent.cellLayout = GridLayout.CellLayout.Rectangle; tilemapOffset = new Vector3(0, -sy, 0); break; } SuperImportContext.TilemapOffset = tilemapOffset; return true; } private bool ProcessTilesetElements(XElement xMap) { Assert.IsNull(m_GlobalTileDatabase); bool success = true; // Our tile database will be fed with tiles from each referenced tileset m_GlobalTileDatabase = new GlobalTileDatabase(); m_InternalTilesets = new List(); foreach (var xTileset in xMap.Elements("tileset")) { if (xTileset.Attribute("source") != null) { success = success && ProcessTilesetElementExternal(xTileset); } else { success = success && ProcessTilesetElementInternal(xTileset); } } return success; } private bool ProcessTilesetElementExternal(XElement xTileset) { Assert.IsNotNull(xTileset); Assert.IsNotNull(m_GlobalTileDatabase); var firstId = xTileset.GetAttributeAs("firstgid"); var source = xTileset.GetAttributeAs("source"); // JSON customized assets are not supported as Unity has the *.json extension reserved if (string.Equals(Path.GetExtension(source), ".json", StringComparison.OrdinalIgnoreCase)) { ReportGenericError($"JSON tilesets are not supported by Unity. Use TSX files instead. Tileset: {source}"); return false; } // Load the tileset and process the tiles inside var tileset = RequestDependencyAssetAtPath(source); if (tileset == null) { // Tileset is missing or was not imported properly return false; } else { // Register all the tiles with the tile database for this map m_GlobalTileDatabase.RegisterTileset(firstId, tileset); } return true; } private bool ProcessTilesetElementInternal(XElement xTileset) { var firstId = xTileset.GetAttributeAs("firstgid"); var name = xTileset.GetAttributeAs("name"); var tileset = ScriptableObject.CreateInstance(); tileset.m_IsInternal = true; tileset.name = name; tileset.m_PixelsPerUnit = PixelsPerUnit; m_InternalTilesets.Add(tileset); string assetName = string.Format("_TilesetScriptObjectInternal_{0}", m_InternalTilesets.Count); SuperImportContext.AddObjectToAsset(assetName, tileset); var loader = new TilesetLoader(tileset, this); if (loader.LoadFromXml(xTileset)) { m_GlobalTileDatabase.RegisterTileset(firstId, tileset); return true; } return false; } private void ProcessMapLayers(GameObject goParent, XElement xMap) { // Note that this method is re-entrant due to group layers foreach (XElement xNode in xMap.Elements()) { if (!xNode.GetAttributeAs("visible", true)) { continue; } LayerIgnoreMode ignoreMode = xNode.GetPropertyAttributeAs(StringConstants.Unity_Ignore, SuperImportContext.LayerIgnoreMode); if (ignoreMode == LayerIgnoreMode.True) { continue; } using (SuperImportContext.BeginLayerIgnoreMode(ignoreMode)) { if (xNode.Name == "layer") { ProcessTileLayer(goParent, xNode); } else if (xNode.Name == "group") { ProcessGroupLayer(goParent, xNode); } else if (xNode.Name == "objectgroup") { ProcessObjectLayer(goParent, xNode); } else if (xNode.Name == "imagelayer") { ProcessImageLayer(goParent, xNode); } } } } private void PostProccessMapLayers(GameObject goParent) { foreach (var layer in goParent.GetComponentsInChildren()) { layer.SetWorldPosition(m_MapComponent, SuperImportContext); } // Refresh all our tilemaps so that needless prefab instance changes don't appear foreach (var tilemap in goParent.GetComponentsInChildren()) { tilemap.RefreshAllTiles(); CalculateChunkCullingBounds(tilemap); } } private static void CalculateChunkCullingBounds(Tilemap tilemap) { // Each tilemap gameobject should have a tilemap renderer // Set the chunk culling bounds of the renderer using the size of the largest sprite in the tilemap var tilemapRenderer = tilemap.gameObject.GetComponent(); if (tilemapRenderer != null) { tilemapRenderer.detectChunkCullingBounds = TilemapRenderer.DetectChunkCullingBounds.Manual; float maxWidth = 0; float maxHeight = 0; var allTiles = tilemap.GetTilesBlock(tilemap.cellBounds); foreach (var tile in allTiles.OfType()) { maxWidth = Mathf.Max(tile.m_Sprite.bounds.size.x, maxWidth); maxHeight = Mathf.Max(tile.m_Sprite.bounds.size.y, maxHeight); // Look out for animated tiles if (!tile.m_AnimationSprites.IsEmpty()) { foreach (var sprite in tile.m_AnimationSprites) { maxWidth = Mathf.Max(sprite.bounds.size.x, maxWidth); maxHeight = Mathf.Max(sprite.bounds.size.y, maxHeight); } } } tilemapRenderer.chunkCullingBounds = new Vector3(maxWidth, maxHeight, 0); } } private void DoPrefabReplacements() { // Should any of our objects (from Tiled) be replaced by instantiated prefabs? var supers = m_MapComponent.GetComponentsInChildren(); m_ObjectsById = supers.ToDictionary(so => so.m_Id, so => so.gameObject); var goToDestroy = new List(); foreach (var so in supers) { var prefab = ST2USettings.instance.GetPrefabReplacement(so.m_Type); if (prefab != null) { // Replace the super object with the instantiated prefab var instance = (GameObject)PrefabUtility.InstantiatePrefab(prefab); instance.transform.SetParent(so.transform.parent); instance.transform.position = so.transform.position + prefab.transform.localPosition; instance.transform.rotation = so.transform.rotation; // Keep the name from Tiled. instance.name = so.gameObject.name; // Update bookkeeping for later custom property replacement. goToDestroy.Add(so.gameObject); m_ObjectsById[so.m_Id] = instance; } } // Now that all the replacements have been instantiated, apply custom properties // where object references can now also point to the new replacement instances. foreach (var so in supers) { // Apply custom properties as messages to the instanced prefab var props = so.GetComponent(); if (props != null) { foreach (var p in props.m_Properties) { m_ObjectsById[so.m_Id].BroadcastProperty(p, m_ObjectsById); } } } // Finally, destroy replaced game objects. foreach (var go in goToDestroy) { DestroyImmediate(go); } } private void DoCustomImporting() { ApplyUserImporter(); ApplyAutoImporters(); } private void ApplyUserImporter() { if (!string.IsNullOrEmpty(m_CustomImporterClassName)) { var type = AppDomain.CurrentDomain.GetTypeFromName(m_CustomImporterClassName); if (type == null) { ReportGenericError($"Custom Importer error. Class type '{m_CustomImporterClassName}' is missing."); return; } RunCustomImporterType(type); } } private void ApplyAutoImporters() { foreach (var type in AutoCustomTmxImporterAttribute.GetOrderedAutoImportersTypes()) { RunCustomImporterType(type); } } private void RunCustomImporterType(Type type) { // Instantiate a custom importer class for specialized projects to use CustomTmxImporter customImporter; try { customImporter = Activator.CreateInstance(type) as CustomTmxImporter; } catch (Exception e) { ReportGenericError($"Error creating custom importer class. Message = '{e.Message}'\n{e.StackTrace}"); return; } try { var args = new TmxAssetImportedArgs(); args.AssetImporter = this; args.ImportedSuperMap = m_MapComponent; customImporter.TmxAssetImported(args); } catch (CustomImporterException cie) { ReportGenericError($"Custom Importer error: \n Importer: {customImporter.GetType().Name}\n Message: {cie.Message}"); Debug.LogErrorFormat("Custom Importer ({0}) exception: {1}", customImporter.GetType().Name, cie.Message); } catch (Exception e) { ReportGenericError($"Custom importer '{customImporter.GetType().Name}' threw an exception. Message = '{e.Message}', Stack:\n{e.StackTrace}"); Debug.LogErrorFormat("Custom importer general exception: {0}", e.Message); } } } }