コード例 #1
0
        public TmxObjectGroup(TmxMap map, XElement xObjectGroup)
        {
            Map     = map;
            Name    = (string)xObjectGroup.Attribute("name") ?? string.Empty;
            Color   = TmxColor.ParseColor(xObjectGroup.Attribute("color"));
            Opacity = (float?)xObjectGroup.Attribute("opacity") ?? 1.0f;
            Visible = (bool?)xObjectGroup.Attribute("visible") ?? true;
            OffsetX = (float?)xObjectGroup.Attribute("offsetx") ?? 0.0f;
            OffsetY = (float?)xObjectGroup.Attribute("offsety") ?? 0.0f;

            var drawOrderDict = new Dictionary <string, DrawOrderType> {
                { "unknown", DrawOrderType.UnknownOrder },
                { "topdown", DrawOrderType.IndexOrder },
                { "index", DrawOrderType.TopDown }
            };

            var drawOrderValue = (string)xObjectGroup.Attribute("draworder");

            if (drawOrderValue != null)
            {
                DrawOrder = drawOrderDict[drawOrderValue];
            }

            Objects = new TmxList <TmxObject>();
            foreach (var e in xObjectGroup.Elements("object"))
            {
                Objects.Add(new TmxObject(map, e));
            }

            Properties = PropertyDict.ParsePropertyDict(xObjectGroup.Element("properties"));
        }
コード例 #2
0
        public TmxTilesetTile(TmxTileset tileset, XElement xTile, TmxList <TmxTerrain> Terrains, string tmxDir = "")
        {
            Tileset = tileset;
            Id      = (int)xTile.Attribute("id");

            var strTerrain = (string)xTile.Attribute("terrain");

            if (strTerrain != null)
            {
                TerrainEdges = new TmxTerrain[4];
                var index = 0;
                foreach (var v in strTerrain.Split(','))
                {
                    var success = int.TryParse(v, out int result);

                    TmxTerrain edge;
                    if (success)
                    {
                        edge = Terrains[result];
                    }
                    else
                    {
                        edge = null;
                    }
                    TerrainEdges[index++] = edge;
                }
            }

            Probability = (double?)xTile.Attribute("probability") ?? 1.0;
            Type        = (string)xTile.Attribute("type");
            var xImage = xTile.Element("image");

            if (xImage != null)
            {
                Image = new TmxImage(xImage, tmxDir);
            }

            ObjectGroups = new TmxList <TmxObjectGroup>();
            foreach (var e in xTile.Elements("objectgroup"))
            {
                ObjectGroups.Add(new TmxObjectGroup(tileset.Map, e));
            }

            AnimationFrames = new List <TmxAnimationFrame>();
            if (xTile.Element("animation") != null)
            {
                foreach (var e in xTile.Element("animation").Elements("frame"))
                {
                    AnimationFrames.Add(new TmxAnimationFrame(e));
                }
            }

            Properties = PropertyDict.ParsePropertyDict(xTile.Element("properties"));

            if (Properties != null)
            {
                ProcessProperties();
            }
        }
コード例 #3
0
        public TmxObject(TmxMap map, XElement xObject)
        {
            Id       = (int?)xObject.Attribute("id") ?? 0;
            Name     = (string)xObject.Attribute("name") ?? string.Empty;
            X        = (float)xObject.Attribute("x");
            Y        = (float)xObject.Attribute("y");
            Width    = (float?)xObject.Attribute("width") ?? 0.0f;
            Height   = (float?)xObject.Attribute("height") ?? 0.0f;
            Type     = (string)xObject.Attribute("type") ?? string.Empty;
            Visible  = (bool?)xObject.Attribute("visible") ?? true;
            Rotation = (float?)xObject.Attribute("rotation") ?? 0.0f;

            // Assess object type and assign appropriate content
            var xGid      = xObject.Attribute("gid");
            var xEllipse  = xObject.Element("ellipse");
            var xPolygon  = xObject.Element("polygon");
            var xPolyline = xObject.Element("polyline");
            var xText     = xObject.Element("text");
            var xPoint    = xObject.Element("point");

            if (xGid != null)
            {
                Tile       = new TmxLayerTile(map, (uint)xGid, Convert.ToInt32(Math.Round(X)), Convert.ToInt32(Math.Round(X)));
                ObjectType = TmxObjectType.Tile;
            }
            else if (xEllipse != null)
            {
                ObjectType = TmxObjectType.Ellipse;
            }
            else if (xPolygon != null)
            {
                Points     = ParsePoints(xPolygon);
                ObjectType = TmxObjectType.Polygon;
            }
            else if (xPolyline != null)
            {
                Points     = ParsePoints(xPolyline);
                ObjectType = TmxObjectType.Polyline;
            }
            else if (xText != null)
            {
                Text       = new TmxText(xText);
                ObjectType = TmxObjectType.Text;
            }
            else if (xPoint != null)
            {
                ObjectType = TmxObjectType.Point;
            }
            else
            {
                ObjectType = TmxObjectType.Basic;
            }

            Properties = PropertyDict.ParsePropertyDict(xObject.Element("properties"));
        }
コード例 #4
0
        public TmxGroup(TmxMap map, XElement xGroup, int width, int height, string tmxDirectory)
        {
            this.map = map;
            Name     = (string)xGroup.Attribute("name") ?? string.Empty;
            Opacity  = (float?)xGroup.Attribute("opacity") ?? 1.0f;
            Visible  = (bool?)xGroup.Attribute("visible") ?? true;
            OffsetX  = (float?)xGroup.Attribute("offsetx") ?? 0.0f;
            OffsetY  = (float?)xGroup.Attribute("offsety") ?? 0.0f;

            Properties = PropertyDict.ParsePropertyDict(xGroup.Element("properties"));

            layers       = new TmxList <ITmxLayer>();
            tileLayers   = new TmxList <TmxLayer>();
            objectGroups = new TmxList <TmxObjectGroup>();
            imageLayers  = new TmxList <TmxImageLayer>();
            groups       = new TmxList <TmxGroup>();
            foreach (var e in xGroup.Elements().Where(x => x.Name == "layer" || x.Name == "objectgroup" || x.Name == "imagelayer" || x.Name == "group"))
            {
                ITmxLayer layer;
                switch (e.Name.LocalName)
                {
                case "layer":
                    var tileLayer = new TmxLayer(map, e, width, height);
                    layer = tileLayer;
                    tileLayers.Add(tileLayer);
                    break;

                case "objectgroup":
                    var objectgroup = new TmxObjectGroup(map, e);
                    layer = objectgroup;
                    objectGroups.Add(objectgroup);
                    break;

                case "imagelayer":
                    var imagelayer = new TmxImageLayer(map, e, tmxDirectory);
                    layer = imagelayer;
                    imageLayers.Add(imagelayer);
                    break;

                case "group":
                    var group = new TmxGroup(map, e, width, height, tmxDirectory);
                    layer = group;
                    groups.Add(group);
                    break;

                default:
                    throw new InvalidOperationException();
                }
                layers.Add(layer);
            }
        }
コード例 #5
0
ファイル: ImageLayer.cs プロジェクト: sherjilozair/Nez
        public TmxImageLayer(TmxMap map, XElement xImageLayer, string tmxDir = "")
        {
            this.Map = map;
            Name     = (string)xImageLayer.Attribute("name");

            Width   = (int?)xImageLayer.Attribute("width");
            Height  = (int?)xImageLayer.Attribute("height");
            Visible = (bool?)xImageLayer.Attribute("visible") ?? true;
            Opacity = (float?)xImageLayer.Attribute("opacity") ?? 1.0f;
            OffsetX = (float?)xImageLayer.Attribute("offsetx") ?? 0.0f;
            OffsetY = (float?)xImageLayer.Attribute("offsety") ?? 0.0f;

            var xImage = xImageLayer.Element("image");

            if (xImage != null)
            {
                Image = new TmxImage(xImage, tmxDir);
            }

            Properties = PropertyDict.ParsePropertyDict(xImageLayer.Element("properties"));
        }
コード例 #6
0
ファイル: Layer.cs プロジェクト: wacharlb/Nez
        public TmxLayer(TmxMap map, XElement xLayer, int width, int height)
        {
            Map     = map;
            Name    = (string)xLayer.Attribute("name");
            Opacity = (float?)xLayer.Attribute("opacity") ?? 1.0f;
            Visible = (bool?)xLayer.Attribute("visible") ?? true;
            OffsetX = (float?)xLayer.Attribute("offsetx") ?? 0.0f;
            OffsetY = (float?)xLayer.Attribute("offsety") ?? 0.0f;
            // TODO: does the width/height passed in ever differ from the TMX layer XML?
            Width  = (int)xLayer.Attribute("width");
            Height = (int)xLayer.Attribute("height");

            var xData    = xLayer.Element("data");
            var encoding = (string)xData.Attribute("encoding");

            Tiles = new TmxLayerTile[width * height];
            if (encoding == "base64")
            {
                var decodedStream = new TmxBase64Data(xData);
                var stream        = decodedStream.Data;

                var index = 0;
                using (var br = new BinaryReader(stream))
                    for (int j = 0; j < height; j++)
                    {
                        for (int i = 0; i < width; i++)
                        {
                            var gid = br.ReadUInt32();
                            Tiles[index++] = gid != 0 ? new TmxLayerTile(map, gid, i, j) : null;
                        }
                    }
            }
            else if (encoding == "csv")
            {
                var csvData = (string)xData.Value;
                int k       = 0;
                foreach (var s in csvData.Split(','))
                {
                    var gid = uint.Parse(s.Trim());
                    var x   = k % width;
                    var y   = k / width;

                    Tiles[k++] = gid != 0 ? new TmxLayerTile(map, gid, x, y) : null;
                }
            }
            else if (encoding == null)
            {
                int k = 0;
                foreach (var e in xData.Elements("tile"))
                {
                    var gid = (uint?)e.Attribute("gid") ?? 0;

                    var x = k % width;
                    var y = k / width;

                    Tiles[k++] = gid != 0 ? new TmxLayerTile(map, gid, x, y) : null;
                }
            }
            else
            {
                throw new Exception("TmxLayer: Unknown encoding.");
            }

            Properties = PropertyDict.ParsePropertyDict(xLayer.Element("properties"));
        }
コード例 #7
0
        public TmxTileset(TmxMap map, XElement xTileset, int firstGid, string tmxDir)
        {
            Map      = map;
            FirstGid = firstGid;

            Name       = (string)xTileset.Attribute("name");
            TileWidth  = (int)xTileset.Attribute("tilewidth");
            TileHeight = (int)xTileset.Attribute("tileheight");
            Spacing    = (int?)xTileset.Attribute("spacing") ?? 0;
            Margin     = (int?)xTileset.Attribute("margin") ?? 0;
            Columns    = (int?)xTileset.Attribute("columns");
            TileCount  = (int?)xTileset.Attribute("tilecount");
            TileOffset = new TmxTileOffset(xTileset.Element("tileoffset"));

            var xImage = xTileset.Element("image");

            if (xImage != null)
            {
                Image = new TmxImage(xImage, tmxDir);
            }

            var xTerrainType = xTileset.Element("terraintypes");

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

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

            Properties = PropertyDict.ParsePropertyDict(xTileset.Element("properties"));

            // cache our source rects for each tile so we dont have to calculate them every time we render. If we have
            // an image this is a normal tileset, else its an image tileset
            TileRegions = new Dictionary <int, RectangleF>();
            if (Image != null)
            {
                var id = firstGid;
                for (var y = Margin; y < Image.Height - Margin; y += TileHeight + Spacing)
                {
                    var column = 0;
                    for (var x = Margin; x < Image.Width - Margin; x += TileWidth + Spacing)
                    {
                        TileRegions.Add(id++, new RectangleF(x, y, TileWidth, TileHeight));

                        if (++column >= Columns)
                        {
                            break;
                        }
                    }
                }
            }
            else
            {
                // it seems that firstGid is always 0 for image tilesets so we can access them like an array here
                var id = firstGid;
                for (var i = 0; i < Tiles.Count; i++)
                {
                    var tile = Tiles[i];
                    TileRegions.Add(id++, new RectangleF(0, 0, tile.Image.Width, tile.Image.Height));
                }
            }
        }
コード例 #8
0
 public TmxTerrain(XElement xTerrain)
 {
     Name       = (string)xTerrain.Attribute("name");
     Tile       = (int)xTerrain.Attribute("tile");
     Properties = PropertyDict.ParsePropertyDict(xTerrain.Element("properties"));
 }