Example #1
0
        public TmxLayer(XMLReader xLayer, int width, int height)
        {
            Name   = xLayer.Attribute("name") ?? "";
            Width  = width;
            Height = height;

            Opacity = xLayer.AttributeFloatN("opacity") ?? 1.0f;
            Visible = xLayer.AttributeBoolN("visible") ?? true;
            OffsetX = xLayer.AttributeFloat("offsetx");
            OffsetY = xLayer.AttributeFloat("offsety");

            Properties = TmxHelpers.GetPropertyDict(xLayer.Element("properties"));

            // Not a layer which contains tiles.
            if (width == 0)
            {
                return;
            }
            XMLReader xData    = xLayer.Element("data");
            string    encoding = xData.Attribute("encoding");

            Tiles = new Collection <TmxLayerTile>();
            switch (encoding)
            {
            case "csv":
            {
                string csvData = xData.CurrentContents();
                foreach (string s in csvData.Split(','))
                {
                    uint gid = uint.Parse(s.Trim());
                    Tiles.Add(new TmxLayerTile(gid));
                }

                break;
            }

            case null:
            {
                foreach (XMLReader e in xData.Elements("tile"))
                {
                    uint gid = e.AttributeUInt("gid");
                    Tiles.Add(new TmxLayerTile(gid));
                }

                break;
            }

            default:
                Engine.Log.Warning($"Unknown tmx layer encoding {encoding}", MessageSource.TMX);
                return;
            }
        }
Example #2
0
        public TmxTileset(XMLReader xTileset)
        {
            FirstGid   = xTileset.AttributeInt("firstgid");
            Name       = xTileset.Attribute("name");
            TileWidth  = xTileset.AttributeInt("tilewidth");
            TileHeight = xTileset.AttributeInt("tileheight");
            Spacing    = xTileset.AttributeIntN("spacing") ?? 0;
            Margin     = xTileset.AttributeInt("margin");
            Columns    = xTileset.AttributeIntN("columns");
            TileCount  = xTileset.AttributeIntN("tilecount");
            TileOffset = TmxHelpers.GetVector2(xTileset.Element("tileoffset"));

            XMLReader image = xTileset.Element("image");

            if (image != null)
            {
                Source = image.Attribute("source");
            }

            Terrains = new TmxList <TmxTerrain>();
            XMLReader xTerrainType = xTileset.Element("terraintypes");

            if (xTerrainType != null)
            {
                foreach (XMLReader e in xTerrainType.Elements("terrain"))
                {
                    Terrains.Add(new TmxTerrain(e));
                }
            }

            Tiles = new Dictionary <int, TmxTilesetTile>();
            foreach (XMLReader xTile in xTileset.Elements("tile"))
            {
                var tile = new TmxTilesetTile(xTile, Terrains);
                Tiles[tile.Id] = tile;
            }

            Properties = TmxHelpers.GetPropertyDict(xTileset.Element("properties"));
        }
Example #3
0
        public TmxMap(XMLReader reader, string?filePath = null)
        {
            XMLReader?xMap = reader.Element("map");

            if (xMap == null)
            {
                return;
            }

            Version      = xMap.Attribute("version");
            TiledVersion = xMap.Attribute("tiledversion");

            Width           = xMap.AttributeInt("width");
            Height          = xMap.AttributeInt("height");
            TileWidth       = xMap.AttributeInt("tilewidth");
            TileHeight      = xMap.AttributeInt("tileheight");
            HexSideLength   = xMap.AttributeIntN("hexsidelength");
            Orientation     = xMap.AttributeEnum <Orientation>("orientation");
            StaggerAxis     = xMap.AttributeEnum <StaggerAxis>("staggeraxis");
            StaggerIndex    = xMap.AttributeEnum <StaggerIndex>("staggerindex");
            RenderOrder     = xMap.AttributeEnum <RenderOrder>("renderorder");
            NextObjectId    = xMap.AttributeIntN("nextobjectid");
            BackgroundColor = TmxHelpers.ParseTmxColor(xMap.Attribute("backgroundcolor"));

            Properties = TmxHelpers.GetPropertyDict(xMap.Element("properties"));

            foreach (XMLReader e in xMap.Elements("tileset"))
            {
                string?fileSource = e.Attribute("source");
                int    firstGid   = e.AttributeInt("firstgid");

                // Check if external file.
                if (!string.IsNullOrEmpty(fileSource))
                {
                    if (filePath != null)
                    {
                        string directory = AssetLoader.GetDirectoryName(filePath);
                        fileSource = AssetLoader.GetNonRelativePath(directory, fileSource);
                    }
                    var textAsset = Engine.AssetLoader.Get <TextAsset>(fileSource);
                    if (textAsset?.Content == null)
                    {
                        Engine.Log.Warning("Couldn't load external tileset.", MessageSource.TMX);
                        continue;
                    }

                    var       externalReader = new XMLReader(textAsset.Content);
                    XMLReader?tileSetElement = externalReader.Element("tileset");
                    if (tileSetElement == null)
                    {
                        continue;
                    }
                    Tilesets.Add(new TmxTileset(firstGid, tileSetElement));
                    continue;
                }

                Tilesets.Add(new TmxTileset(firstGid, e));
            }

            foreach (XMLReader e in xMap.Elements().Where(x => x.Name == "layer" || x.Name == "objectgroup" || x.Name == "imagelayer" || x.Name == "group"))
            {
                TmxLayer layer;
                switch (e.Name)
                {
                case "layer":
                    var tileLayer = new TmxLayer(e, Width, Height);
                    layer = tileLayer;
                    TileLayers.Add(tileLayer);
                    break;

                case "objectgroup":
                    var objectLayer = new TmxObjectLayer(e);
                    layer = objectLayer;
                    ObjectLayers.Add(objectLayer);
                    break;

                case "imagelayer":
                    var imageLayer = new TmxImageLayer(e);
                    layer = imageLayer;
                    ImageLayers.Add(imageLayer);
                    break;

                case "group":
                    var group = new TmxGroupedLayers(e, Width, Height);
                    layer = group;
                    Groups.Add(group);
                    break;

                default:
                    Engine.Log.Warning($"Unknown TMX layer type {e.Name}.", MessageSource.TMX);
                    continue;
                }

                Layers.Add(layer);
            }
        }
 public TmxTerrain(XMLReader xTerrain)
 {
     Name       = xTerrain.Attribute("name");
     Tile       = xTerrain.AttributeInt("tile");
     Properties = TmxHelpers.GetPropertyDict(xTerrain.Element("properties"));
 }
Example #5
0
        public TmxMap(XMLReader reader)
        {
            XMLReader xMap = reader.Element("map");

            Version      = xMap.Attribute("version");
            TiledVersion = xMap.Attribute("tiledversion");

            Width           = xMap.AttributeInt("width");
            Height          = xMap.AttributeInt("height");
            TileWidth       = xMap.AttributeInt("tilewidth");
            TileHeight      = xMap.AttributeInt("tileheight");
            HexSideLength   = xMap.AttributeIntN("hexsidelength");
            Orientation     = xMap.AttributeEnum <Orientation>("orientation");
            StaggerAxis     = xMap.AttributeEnum <StaggerAxis>("staggeraxis");
            StaggerIndex    = xMap.AttributeEnum <StaggerIndex>("staggerindex");
            RenderOrder     = xMap.AttributeEnum <RenderOrder>("renderorder");
            NextObjectId    = xMap.AttributeIntN("nextobjectid");
            BackgroundColor = TmxHelpers.ParseTmxColor(xMap.Attribute("backgroundcolor"));

            Properties = TmxHelpers.GetPropertyDict(xMap.Element("properties"));

            Tilesets = new TmxList <TmxTileset>();
            foreach (XMLReader e in xMap.Elements("tileset"))
            {
                Tilesets.Add(new TmxTileset(e));
            }

            Layers       = new TmxList <TmxLayer>();
            TileLayers   = new TmxList <TmxLayer>();
            ObjectLayers = new TmxList <TmxObjectLayer>();
            ImageLayers  = new TmxList <TmxImageLayer>();
            Groups       = new TmxList <TmxGroupedLayers>();
            foreach (XMLReader e in xMap.Elements().Where(x => x.Name == "layer" || x.Name == "objectgroup" || x.Name == "imagelayer" || x.Name == "group"))
            {
                TmxLayer layer;
                switch (e.Name)
                {
                case "layer":
                    var tileLayer = new TmxLayer(e, Width, Height);
                    layer = tileLayer;
                    TileLayers.Add(tileLayer);
                    break;

                case "objectgroup":
                    var objectLayer = new TmxObjectLayer(e);
                    layer = objectLayer;
                    ObjectLayers.Add(objectLayer);
                    break;

                case "imagelayer":
                    var imageLayer = new TmxImageLayer(e);
                    layer = imageLayer;
                    ImageLayers.Add(imageLayer);
                    break;

                case "group":
                    var group = new TmxGroupedLayers(e, Width, Height);
                    layer = group;
                    Groups.Add(group);
                    break;

                default:
                    Engine.Log.Warning($"Unknown TMX layer type {e.Name}.", MessageSource.TMX);
                    continue;
                }

                Layers.Add(layer);
            }
        }
        public TmxObject(XMLReader xObject)
        {
            Id       = xObject.AttributeInt("id");
            Name     = xObject.Attribute("name") ?? string.Empty;
            X        = xObject.AttributeDouble("x");
            Y        = xObject.AttributeDouble("y");
            Width    = xObject.AttributeDouble("width");
            Height   = xObject.AttributeDouble("height");
            Type     = xObject.Attribute("type") ?? string.Empty;
            Visible  = xObject.AttributeBoolN("visible") ?? true;
            Rotation = xObject.AttributeDouble("rotation");

            // Assess object type and assign appropriate content
            uint?rawGid = xObject.AttributeUIntN("gid");

            if (rawGid != null)
            {
                Gid = TmxHelpers.GetGidFlags((uint)rawGid, out HorizontalFlip, out VerticalFlip, out DiagonalFlip);
            }

            XMLReader xEllipse  = xObject.Element("ellipse");
            XMLReader xPolygon  = xObject.Element("polygon");
            XMLReader xPolyline = xObject.Element("polyline");

            if (Gid != null)
            {
                ObjectType = TmxObjectType.Image;
                // In Tiled an image's X,Y coordinates represent the bottom-left corner of the image
                Y -= Height;
            }
            else if (xEllipse != null)
            {
                ObjectType = TmxObjectType.Ellipse;
            }
            else if (xPolygon != null)
            {
                Points     = ParsePoints(xPolygon);
                ObjectType = TmxObjectType.Polygon;
            }
            else if (xPolyline != null)
            {
                List <Vector2> points = ParsePoints(xPolyline);
                Lines = new List <LineSegment>(points.Count / 2);
                for (var i = 0; i < points.Count; i++)
                {
                    if (i + 1 < points.Count)
                    {
                        Lines.Add(new LineSegment(points[i], points[i + 1]));
                    }
                }
                ObjectType = TmxObjectType.Polyline;
            }
            else
            {
                ObjectType = TmxObjectType.Basic;
            }

            XMLReader xText = xObject.Element("text");

            if (xText != null)
            {
                Text = new TmxText(xText);
            }

            Properties = TmxHelpers.GetPropertyDict(xObject.Element("properties"));
        }
 public TmxImageLayer(XMLReader xImageLayer) : base(xImageLayer, xImageLayer.AttributeInt("width"), xImageLayer.AttributeInt("height"))
 {
     Image = xImageLayer.Element("image").CurrentContents();
 }