static void CreatePalette(string tilesetName, string tilesetTileTargetDir, ImportedTile[] tileAssets, bool singleImageTileset, int tileWidth, int tileHeight, int columns, int cellWidth, int cellHeight)
{
GameObject newPaletteGO = new GameObject(tilesetName, typeof(Grid));
newPaletteGO.GetComponent <Grid>().cellSize = new Vector3(1.0f, 1.0f, 0.0f);
GameObject paletteTilemapGO = new GameObject("Layer1", typeof(Tilemap), typeof(TilemapRenderer));
paletteTilemapGO.transform.SetParent(newPaletteGO.transform);
paletteTilemapGO.GetComponent <TilemapRenderer>().enabled = false;
Tilemap paletteTilemap = paletteTilemapGO.GetComponent <Tilemap>();
paletteTilemap.tileAnchor = TiledTSXImporter.GetPivot(tileWidth, tileHeight, cellWidth, cellHeight);
if (columns <= 0)
{
columns = 5;
}
if (singleImageTileset)
{
for (int i = 0; i < tileAssets.Length; i++)
{
Sprite sprite = tileAssets[i].tile.sprite;
Rect rect = sprite.rect;
int x = (int)rect.x / tileWidth;
int y = (int)rect.y / tileHeight;
paletteTilemap.SetTile(new Vector3Int(x, y, 0), tileAssets[i].tile);
}
}
else
{
int x = 0;
int y = 0;
for (int i = 0; i < tileAssets.Length; i++)
{
paletteTilemap.SetTile(new Vector3Int(x, y, 0), tileAssets[i].tile);
x++;
if (x >= columns)
{
x = 0;
y--;
}
}
}
string palettePath = tilesetTileTargetDir + Path.DirectorySeparatorChar + tilesetName + ".prefab";
palettePath = palettePath.Replace('\\', '/');
UnityEngine.Object newPrefab = PrefabUtility.CreateEmptyPrefab(palettePath);
PrefabUtility.ReplacePrefab(newPaletteGO, newPrefab, ReplacePrefabOptions.Default);
GameObject.DestroyImmediate(newPaletteGO);
GridPalette gridPalette = ScriptableObject.CreateInstance <GridPalette>();
gridPalette.cellSizing = GridPalette.CellSizing.Automatic;
gridPalette.name = "Palette Settings";
AssetDatabase.AddObjectToAsset(gridPalette, palettePath);
AssetDatabase.ImportAsset(palettePath);
}
public static ImportedTemplate LoadTXFile(string path, string tilesetDir, int cellWidth, int cellHeight, int pixelsPerUnit)
{
TXTypes.Template template = ImportUtils.ReadXMLIntoObject <TXTypes.Template>(path);
ImportedTileset tileset;
if (template.tileset != null)
{
string baseFolder = Path.GetDirectoryName(path);
tileset = TiledTSXImporter.ImportFromTilesetReference(template.tileset, baseFolder, tilesetDir, cellWidth, cellHeight, pixelsPerUnit);
}
else
{
tileset = null;
}
return(new ImportedTemplate(template, tileset));
}
public static Sprite ImportPathAsSprite(string tmxFolderPath, string relativeSourcePath, string storageFolder, int pixelsPerUnit)
{
string imageSourcePath;
string imageTargetPath;
CreateSingleImagePaths(relativeSourcePath, tmxFolderPath, storageFolder, out imageSourcePath, out imageTargetPath);
TiledTSXImporter.CopyImages(new string[] { imageSourcePath }, new string[] { imageTargetPath });
if (File.Exists(imageTargetPath))
{
TextureImporter ti = AssetImporter.GetAtPath(imageTargetPath) as TextureImporter;
TextureImporterSettings textureSettings = new TextureImporterSettings();
ti.ReadTextureSettings(textureSettings);
SpriteMeshType meshType = SpriteMeshType.FullRect;
SpriteAlignment alignment = SpriteAlignment.TopLeft;
FilterMode filterMode = FilterMode.Point;
if (textureSettings.spritePixelsPerUnit != pixelsPerUnit ||
textureSettings.spriteMeshType != meshType ||
textureSettings.spriteAlignment != (int)alignment ||
textureSettings.filterMode != filterMode)
{
textureSettings.spritePixelsPerUnit = pixelsPerUnit;
textureSettings.spriteMeshType = meshType;
textureSettings.spriteAlignment = (int)alignment;
textureSettings.filterMode = filterMode;
ti.SetTextureSettings(textureSettings);
EditorUtility.SetDirty(ti);
ti.SaveAndReimport();
}
Sprite newSprite = AssetDatabase.LoadAssetAtPath <Sprite> (imageTargetPath);
Debug.Assert(newSprite != null);
return(newSprite);
}
else
{
return(null);
}
}
public static ImportedTileset ImportFromTilesetReference(TMX.TilesetReference tilesetReference, string baseFolder, string tilesetDir, int cellWidth, int cellHeight, int pixelsPerUnit)
{
// The source path in the tileset reference is recorded relative to the tmx
TSX.Tileset actualTileset;
ImportedTile[] importedTiles;
if (tilesetReference.source != null)
{
string tsxPath = Path.Combine(baseFolder, tilesetReference.source);
importedTiles = TiledTSXImporter.ImportTSXFile(tsxPath, tilesetDir, cellWidth, cellHeight, pixelsPerUnit, out actualTileset);
}
else
{
importedTiles = TiledTSXImporter.ImportEmbeddedTileset(tilesetReference, tilesetDir, baseFolder, cellWidth, cellHeight, pixelsPerUnit, out actualTileset);
}
if (importedTiles == null || (importedTiles.Length > 0 && importedTiles[0] == null))
{
Debug.LogError("Failed to import tileset " + (tilesetReference.source != null ? tilesetReference.source : tilesetReference.name) + " properly...");
return(null);
}
return(new ImportedTileset(importedTiles, tilesetReference.firstgid, actualTileset));
}
/* Entry point into this class */
public static bool ImportTMXFile(string path, string inTilesetDir, Grid targetGrid, string inImageLayerSpriteDir, bool setHiddenLayersToInactive)
{
s_tmxParentFolder = Path.GetDirectoryName(path);
string filename = Path.GetFileNameWithoutExtension(path);
s_imageLayerSpriteDir = inImageLayerSpriteDir;
s_tilesetDir = inTilesetDir;
s_orderInLayer = 0;
s_setHiddenLayersToInactive = setHiddenLayersToInactive;
s_map = ImportUtils.ReadXMLIntoObject <TMX.Map>(path);
if (s_map == null)
{
return(false);
}
if (s_map.backgroundcolor != null)
{
Color backgroundColor;
if (ColorUtility.TryParseHtmlString(s_map.backgroundcolor, out backgroundColor))
{
Camera.main.backgroundColor = backgroundColor;
}
}
if (s_map.tilesets != null)
{
// First we need to load (or import) all the tilesets referenced by the TMX file...
s_cellWidth = s_map.tilewidth;
s_cellHeight = s_map.tileheight;
s_pixelsPerUnit = Mathf.Max(s_map.tilewidth, s_map.tileheight);
s_importedTilesets = new ImportedTileset[s_map.tilesets.Length];
for (int i = 0; i < s_map.tilesets.Length; i++)
{
s_importedTilesets[i] = TiledTSXImporter.ImportFromTilesetReference(s_map.tilesets[i], s_tmxParentFolder, s_tilesetDir, s_cellWidth, s_cellHeight, s_pixelsPerUnit);
if (s_importedTilesets[i] == null || s_importedTilesets[i].tiles == null || s_importedTilesets[i].tiles[0] == null)
{
Debug.LogError("Imported tileset is incomplete");
return(false);
}
}
// Set up the Grid to store everything in
s_gridGO = PrepareGrid(filename, targetGrid);
s_importOperations = ImportUtils.GetObjectsThatImplementInterface <ITilemapImportOperation>();
s_sortOrder = TilemapRenderer.SortOrder.TopLeft;
if (s_map.renderorder != null)
{
if (s_map.renderorder.Equals("right-down"))
{
s_sortOrder = TilemapRenderer.SortOrder.TopLeft;
}
else if (s_map.renderorder.Equals("right-up"))
{
s_sortOrder = TilemapRenderer.SortOrder.BottomLeft;
}
else if (s_map.renderorder.Equals("left-down"))
{
s_sortOrder = TilemapRenderer.SortOrder.TopRight;
}
else if (s_map.renderorder.Equals("left-up"))
{
s_sortOrder = TilemapRenderer.SortOrder.BottomRight;
}
}
// Unity's isometric rendering only works well with TopRight sortorder
if (s_map.orientation == "isometric")
{
s_sortOrder = TilemapRenderer.SortOrder.TopRight;
}
// Unity hex grid only supports even stagger index, so we need a workaround to compensate
TileLayerImporter.s_needsHexOddToEvenConversion = s_map.orientation == "hexagonal" && s_map.staggerindex == "odd";
// Unity's isometric rendering is 90 degrees rotated anti-clockwise on the grid compared to Tiled,
// so we need to rotate the grid clockwise 90 degrees to look correct in Unity
TileLayerImporter.s_needsGridRotationToMatchUnityIsometric = s_map.orientation == "isometric";
ObjectLayerImporter.s_importedTemplates = new Dictionary <string, ImportedTemplate>();
bool loadedLayers = false;
if (s_map.topLevelLayers != null)
{
loadedLayers = TreatLayers(s_gridGO, s_map.topLevelLayers);
}
else
{
loadedLayers = true;
}
// Handle the complete map's properties
if (loadedLayers)
{
HandleCustomProperties(s_gridGO, s_map.properties);
}
}
return(true);
}
static void CreatePalette(string tilesetName, string tilesetTileTargetDir, ImportedTile[] tileAssets, bool singleImageTileset, int tileWidth, int tileHeight, int columns, int cellWidth, int cellHeight)
{
GameObject newPaletteGO = new GameObject(tilesetName, typeof(Grid));
newPaletteGO.GetComponent <Grid>().cellSize = new Vector3(1.0f, 1.0f, 0.0f);
GameObject paletteTilemapGO = new GameObject("Layer1", typeof(Tilemap), typeof(TilemapRenderer));
paletteTilemapGO.transform.SetParent(newPaletteGO.transform);
paletteTilemapGO.GetComponent <TilemapRenderer>().enabled = false;
Tilemap paletteTilemap = paletteTilemapGO.GetComponent <Tilemap>();
paletteTilemap.tileAnchor = TiledTSXImporter.GetPivot(tileWidth, tileHeight, cellWidth, cellHeight);
if (columns <= 0)
{
columns = 5;
}
if (singleImageTileset)
{
for (int i = 0; i < tileAssets.Length; i++)
{
Sprite sprite = tileAssets[i].tile.sprite;
Rect rect = sprite.rect;
int x = (int)rect.x / tileWidth;
int y = (int)rect.y / tileHeight;
paletteTilemap.SetTile(new Vector3Int(x, y, 0), tileAssets[i].tile);
}
}
else
{
int x = 0;
int y = 0;
for (int i = 0; i < tileAssets.Length; i++)
{
paletteTilemap.SetTile(new Vector3Int(x, y, 0), tileAssets[i].tile);
x++;
if (x >= columns)
{
x = 0;
y--;
}
}
}
string palettePath = tilesetTileTargetDir + Path.DirectorySeparatorChar + tilesetName + ".prefab";
palettePath = palettePath.Replace('\\', '/');
bool createdPrefab = false;
GameObject newPrefab = PrefabUtility.SaveAsPrefabAsset(newPaletteGO, palettePath, out createdPrefab);
Debug.Log("Created tile palette asset = " + createdPrefab);
AssetDatabase.SaveAssets();
UnityEngine.GameObject.DestroyImmediate(newPaletteGO);
// Clear out any old subassets
UnityEngine.Object[] assets = AssetDatabase.LoadAllAssetsAtPath(palettePath);
for (int i = 0; i < assets.Length; i++)
{
UnityEngine.Object asset = assets[i];
if (!AssetDatabase.IsMainAsset(asset) && asset is GridPalette)
{
UnityEngine.Object.DestroyImmediate(asset, true);
}
}
GridPalette gridPalette = ScriptableObject.CreateInstance <GridPalette>();
gridPalette.cellSizing = GridPalette.CellSizing.Automatic;
gridPalette.name = "Palette Settings";
AssetDatabase.AddObjectToAsset(gridPalette, newPrefab);
AssetDatabase.SaveAssets();
}
public static bool ImportTMXFile(string path, string tilesetDir, Grid targetGrid)
{
string tmxParentFolder = Path.GetDirectoryName(path);
string filename = Path.GetFileNameWithoutExtension(path);
TMX.Map map = ImportUtils.ReadXMLIntoObject <TMX.Map>(path);
if (map == null)
{
return(false);
}
if (map.backgroundcolor != null)
{
Color backgroundColor;
if (ColorUtility.TryParseHtmlString(map.backgroundcolor, out backgroundColor))
{
Camera.main.backgroundColor = backgroundColor;
}
}
if (map.tilesets != null)
{
// First we need to load (or import) all the tilesets referenced by the TMX file...
int cellWidth = map.tilewidth;
int cellHeight = map.tileheight;
int pixelsPerUnit = Mathf.Max(map.tilewidth, map.tileheight);
ImportedTileset[] importedTilesets = new ImportedTileset[map.tilesets.Length];
for (int i = 0; i < map.tilesets.Length; i++)
{
importedTilesets[i] = TiledTSXImporter.ImportFromTilesetReference(map.tilesets[i], tmxParentFolder, tilesetDir, cellWidth, cellHeight, pixelsPerUnit);
if (importedTilesets[i] == null || importedTilesets[i].tiles == null || importedTilesets[i].tiles[0] == null)
{
Debug.LogError("Imported tileset is incomplete");
return(false);
}
}
// Set up the Grid to store everything in
GameObject newGrid = null;
if (targetGrid != null)
{
newGrid = targetGrid.gameObject;
for (int i = newGrid.transform.childCount - 1; i >= 0; --i)
{
Undo.DestroyObjectImmediate(newGrid.transform.GetChild(i).gameObject);
}
}
else
{
newGrid = new GameObject(filename, typeof(Grid));
newGrid.GetComponent <Grid>().cellSize = new Vector3(1.0f, 1.0f, 0.0f);
Undo.RegisterCreatedObjectUndo(newGrid, "Import map to new Grid");
}
ITilemapImportOperation[] importOperations = ImportUtils.GetObjectsThatImplementInterface <ITilemapImportOperation>();
TilemapRenderer.SortOrder sortOrder = TilemapRenderer.SortOrder.TopLeft;
if (map.renderorder.Equals("right-down"))
{
sortOrder = TilemapRenderer.SortOrder.TopLeft;
}
else if (map.renderorder.Equals("right-up"))
{
sortOrder = TilemapRenderer.SortOrder.BottomLeft;
}
else if (map.renderorder.Equals("left-down"))
{
sortOrder = TilemapRenderer.SortOrder.TopRight;
}
else if (map.renderorder.Equals("left-up"))
{
sortOrder = TilemapRenderer.SortOrder.BottomRight;
}
// Load all the tile layers
if (map.layers != null)
{
for (int i = 0; i < map.layers.Length; i++)
{
TMX.Layer layer = map.layers[i];
bool success = ImportTileLayer(layer, newGrid, i, importedTilesets, importOperations, sortOrder, cellWidth, cellHeight, map.infinite);
if (!success)
{
return(false);
}
}
}
Dictionary <string, ImportedTemplate> importedTemplates = new Dictionary <string, ImportedTemplate>();
// Load all the objects
if (map.objectgroups != null)
{
for (int g = 0; g < map.objectgroups.Length; g++)
{
TMX.ObjectGroup objectGroup = map.objectgroups[g];
if (objectGroup != null && objectGroup.objects != null && objectGroup.objects.Length > 0)
{
GameObject newObjectLayer = new GameObject(objectGroup.name);
newObjectLayer.transform.SetParent(newGrid.transform, false);
Undo.RegisterCreatedObjectUndo(newObjectLayer, "Import object layer");
int sortingLayer = (map.layers == null ? 0 : map.layers.Length) + g;
for (int i = 0; i < objectGroup.objects.Length; i++)
{
TMX.Object mapObject = objectGroup.objects[i];
bool success = ImportMapObject(mapObject, importedTilesets, importedTemplates, newObjectLayer, map.tilewidth, map.tileheight, sortingLayer, importOperations, tilesetDir, cellWidth, cellHeight, pixelsPerUnit, tmxParentFolder);
if (!success)
{
return(false);
}
}
Color objectColour = new Color(1.0f, 1.0f, 1.0f, 1.0f);
if (objectGroup.color != null)
{
ColorUtility.TryParseHtmlString(objectGroup.color, out objectColour);
}
if (objectGroup.opacity != 1.0f)
{
objectColour.a = objectGroup.opacity;
}
SpriteRenderer[] renderers = newObjectLayer.GetComponentsInChildren <SpriteRenderer>();
foreach (SpriteRenderer r in renderers)
{
r.color = objectColour;
}
if (!objectGroup.visible)
{
foreach (SpriteRenderer r in renderers)
{
r.enabled = false;
}
}
IDictionary <string, string> properties = (objectGroup.properties == null ? new Dictionary <string, string>() : objectGroup.properties.ToDictionary());
foreach (ITilemapImportOperation operation in importOperations)
{
operation.HandleCustomProperties(newObjectLayer, properties);
}
}
}
}
}
return(true);
}
