示例#1
0
        static bool ImportTileLayer(TMX.Layer layer, GameObject newGrid, int layerID, ImportedTileset[] importedTilesets, ITilemapImportOperation[] importOperations,
                                    TilemapRenderer.SortOrder tileSortOrder, int cellWidth, int cellHeight, bool infinite)
        {
            if (infinite != (layer.data.chunks != null))
            {
                Debug.LogError("Our map infinite setting is " + infinite + " but our chunks value is " + layer.data.chunks);
                return(false);
            }
            GameObject newLayer = new GameObject(layer.name, typeof(Tilemap), typeof(TilemapRenderer));

            newLayer.transform.SetParent(newGrid.transform, false);
            Tilemap layerTilemap = newLayer.GetComponent <Tilemap>();

            layerTilemap.tileAnchor = new Vector2(0.5f, 0.5f);
            if (layer.opacity < 1.0f)
            {
                layerTilemap.color = new Color(1.0f, 1.0f, 1.0f, layer.opacity);
            }

            if (layer.data.chunks != null)
            {
                for (int c = 0; c < layer.data.chunks.Length; c++)
                {
                    TMX.Chunk chunk   = layer.data.chunks[c];
                    bool      success = AddChunkToTilemap(layerTilemap, layer.data.encoding, layer.data.compression, chunk.tiles, chunk.text,
                                                          chunk.x, chunk.y, chunk.width, chunk.height, importedTilesets, cellWidth, cellHeight);
                    if (!success)
                    {
                        return(false);
                    }
                }
            }
            else
            {
                bool success = AddChunkToTilemap(layerTilemap, layer.data.encoding, layer.data.compression, layer.data.tiles, layer.data.text,
                                                 0, 0, layer.width, layer.height, importedTilesets, cellWidth, cellHeight);
                if (!success)
                {
                    return(false);
                }
            }

            TilemapRenderer renderer = newLayer.GetComponent <TilemapRenderer>();

            renderer.sortingOrder = layerID;
            renderer.sortOrder    = tileSortOrder;
            if (!layer.visible)
            {
                renderer.enabled = false;
            }

            IDictionary <string, string> properties = (layer.properties == null ? new Dictionary <string, string>() : layer.properties.ToDictionary());

            foreach (ITilemapImportOperation operation in importOperations)
            {
                operation.HandleCustomProperties(newLayer, properties);
            }
            Undo.RegisterCreatedObjectUndo(newLayer, "Import tile layer");
            return(true);
        }
示例#2
0
        internal static bool ImportTileLayer(TMX.Layer layer, GameObject parent, int layerID, bool infinite, out GameObject newLayer)
        {
            newLayer = null;
            if (infinite != (layer.data.chunks != null))
            {
                Debug.LogError("Our map infinite setting is " + infinite + " but our chunks value is " + layer.data.chunks);
                return(false);
            }
            newLayer = new GameObject(layer.name, typeof(Tilemap), typeof(TilemapRenderer));
            newLayer.transform.SetParent(parent.transform, false);
            TiledTMXImporter.SetupLayerOffset(newLayer, layer.offsetx, layer.offsety);
            Tilemap layerTilemap = newLayer.GetComponent <Tilemap>();
            Grid    tileGrid     = TiledTMXImporter.s_gridGO.GetComponent <Grid>();

            if (tileGrid.cellLayout == GridLayout.CellLayout.Hexagon)
            {
                layerTilemap.tileAnchor = new Vector3(0.0f, 0.0f); // Seems to play better with how Unity renders the hex sprites
            }
            else if (tileGrid.cellLayout == GridLayout.CellLayout.Isometric || tileGrid.cellLayout == GridLayout.CellLayout.IsometricZAsY)
            {
                layerTilemap.tileAnchor = new Vector3(0.0f, -1.0f); // Isometric tile anchors are at the bottom of the tile
            }
            else
            {
                layerTilemap.tileAnchor = new Vector2(0.5f, 0.5f);
            }
            if (layer.opacity < 1.0f)
            {
                layerTilemap.color = new Color(1.0f, 1.0f, 1.0f, layer.opacity);
            }

            int     gridXOffset    = 0;
            int     gridYOffset    = 0;
            Vector3 offsetPosition = newLayer.transform.position;

            if (tileGrid.cellLayout == GridLayout.CellLayout.Hexagon)
            {
                HandleHexagonOffsetting(tileGrid.cellSize, out gridXOffset, out gridYOffset, out offsetPosition);
            }
            newLayer.transform.position = offsetPosition;
            if (layer.data.chunks != null)
            {
                for (int c = 0; c < layer.data.chunks.Length; c++)
                {
                    TMX.Chunk chunk   = layer.data.chunks[c];
                    bool      success = AddChunkToTilemap(layerTilemap, layer.data.encoding, layer.data.compression, chunk.tiles, chunk.text,
                                                          chunk.x + gridXOffset, chunk.y + gridYOffset, chunk.width, chunk.height);
                    if (!success)
                    {
                        return(false);
                    }
                }
            }
            else
            {
                bool success = AddChunkToTilemap(layerTilemap, layer.data.encoding, layer.data.compression, layer.data.tiles, layer.data.text,
                                                 gridXOffset, gridYOffset, layer.width, layer.height);
                if (!success)
                {
                    return(false);
                }
            }

            TilemapRenderer renderer = newLayer.GetComponent <TilemapRenderer>();

            renderer.sortingOrder = layerID;
            renderer.sortOrder    = TiledTMXImporter.s_sortOrder;

            return(true);
        }