예제 #1
0
        CCTMXLayer(CCTMXTilesetInfo tileSetInfo, CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo, CCSize layerSize,
                   int totalNumberOfTiles, int tileCapacity, CCTexture2D texture)
            : base(texture, tileCapacity)
        {
            // layerInfo
            LayerName  = layerInfo.Name;
            LayerSize  = layerSize;
            Tiles      = layerInfo.Tiles;
            minGID     = layerInfo.MinGID;
            maxGID     = layerInfo.MaxGID;
            opacity    = layerInfo.Opacity;
            Properties = new Dictionary <string, string>(layerInfo.Properties);

            // TileSetInfo
            TileSet = tileSetInfo;

            // mapInfo
            MapTileSize      = mapInfo.TileSize;
            LayerOrientation = (CCTMXOrientation)mapInfo.Orientation;

            // offset (after layer orientation is set);
            CCPoint offset = ApplyLayerOffset(layerInfo.Offset);

            Position = offset;

            atlasIndexArray = new List <int>((int)totalNumberOfTiles);

            var contentSize = new CCSize(LayerSize.Width * MapTileSize.Width,
                                         LayerSize.Height * MapTileSize.Height);

            ContentSize = contentSize;

            useAutomaticVertexZ = false;
            vertexZvalue        = 0;
        }
예제 #2
0
        // Methods solely used for construction

        void BuildWithMapInfo(CCTMXMapInfo mapInfo)
        {
            MapInfo        = mapInfo;
            MapSize        = mapInfo.MapSize;
            TileSize       = mapInfo.TileSize;
            MapOrientation = mapInfo.Orientation;
            ObjectGroups   = mapInfo.ObjectGroups;
            Properties     = mapInfo.Properties;
            TileProperties = mapInfo.TileProperties;

            int idx = 0;

            List <CCTMXLayerInfo> layers = mapInfo.Layers;

            if (layers != null && layers.Count > 0)
            {
                foreach (CCTMXLayerInfo layerInfo in layers)
                {
                    if (layerInfo.Visible)
                    {
                        CCTMXLayer child = ParseLayer(layerInfo, mapInfo);
                        AddChild(child, idx, idx);

                        // update content size with the max size
                        CCSize childSize   = child.ContentSize;
                        CCSize currentSize = ContentSize;
                        currentSize.Width  = Math.Max(currentSize.Width, childSize.Width);
                        currentSize.Height = Math.Max(currentSize.Height, childSize.Height);
                        ContentSize        = currentSize;

                        idx++;
                    }
                }
            }
        }
예제 #3
0
        public void TextHandler(object ctx, byte[] ch, int len)
        {
            CCTMXMapInfo pTMXMapInfo = this;

            if (pTMXMapInfo.StoringCharacters)
            {
                pTMXMapInfo.CurrentString = ch;
            }
        }
예제 #4
0
        CCTMXLayer ParseLayer(CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo)
        {
            CCTMXTilesetInfo tileset = TilesetForLayer(layerInfo, mapInfo);
            CCTMXLayer       layer   = new CCTMXLayer(tileset, layerInfo, mapInfo);

            // tell the layerinfo to release the ownership of the tiles map.
            layerInfo.OwnTiles = false;
            layer.SetupTiles();

            return(layer);
        }
예제 #5
0
        CCTMXTilesetInfo TilesetForLayer(CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo)
        {
            CCSize size = layerInfo.LayerSize;
            List <CCTMXTilesetInfo> tilesets = mapInfo.Tilesets;

            if (tilesets != null && tilesets.Count > 0)
            {
                for (int i = tilesets.Count - 1; i >= 0; i--)
                {
                    CCTMXTilesetInfo tileset = tilesets[i];
                    if (tileset != null)
                    {
                        for (int y = 0; y < size.Height; y++)
                        {
                            for (int x = 0; x < size.Width; x++)
                            {
                                var  pos = (int)(x + size.Width * y);
                                uint gid = layerInfo.Tiles[pos];

                                // XXX: gid == 0 --> empty tile
                                if (gid != 0)
                                {
                                    // Optimization: quick return
                                    // if the layer is invalid (more than 1 tileset per layer) an CCAssert will be thrown later
                                    if ((gid & CCTMXTileFlags.FlippedMask) >= tileset.FirstGid)
                                    {
                                        return(tileset);
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // If all the tiles are 0, return empty tileset
            CCLog.Log("CocosSharp: Warning: TMX Layer '{0}' has no tiles", layerInfo.Name);
            return(null);
        }
예제 #6
0
        CCTMXLayer(CCTMXTilesetInfo tileSetInfo, CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo, CCSize layerSize, 
            int totalNumberOfTiles, int tileCapacity, CCTexture2D texture)
            : base(texture, tileCapacity)
        {
            // layerInfo
            LayerName = layerInfo.Name;
            LayerSize = layerSize;
            Tiles = layerInfo.Tiles;
            minGID = layerInfo.MinGID;
            maxGID = layerInfo.MaxGID;
            opacity = layerInfo.Opacity;
            Properties = new Dictionary<string, string>(layerInfo.Properties);

            // TileSetInfo
            TileSet = tileSetInfo;

            // mapInfo
            MapTileSize = mapInfo.TileSize;
            LayerOrientation = (CCTMXOrientation) mapInfo.Orientation;

            // offset (after layer orientation is set);
            CCPoint offset = ApplyLayerOffset(layerInfo.Offset);
            Position = offset;

            atlasIndexArray = new List<int>((int) totalNumberOfTiles);

            var contentSize = new CCSize(LayerSize.Width * MapTileSize.Width,
                LayerSize.Height * MapTileSize.Height);

            ContentSize = contentSize;

            useAutomaticVertexZ = false;
            vertexZvalue = 0;
        }
예제 #7
0
 CCTMXLayer(CCTMXTilesetInfo tileSetInfo, CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo, CCSize layerSize, int totalNumberOfTiles) 
     : this(tileSetInfo, layerInfo, mapInfo, layerSize, totalNumberOfTiles, (int)(totalNumberOfTiles * 0.35f + 1), 
         CCTextureCache.SharedTextureCache.AddImage(tileSetInfo.SourceImage))
 {
 }
예제 #8
0
        // Private constructor chaining

        CCTMXLayer(CCTMXTilesetInfo tileSetInfo, CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo, CCSize layerSize) 
            : this(tileSetInfo, layerInfo, mapInfo, layerSize, (int)(layerSize.Width * layerSize.Height))
        {
        }
예제 #9
0
 public CCTMXLayer(CCTMXTilesetInfo tileSetInfo, CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo)
     : this(tileSetInfo, layerInfo, mapInfo, layerInfo.LayerSize)
 {
 }
예제 #10
0
        // Methods solely used for construction

        void BuildWithMapInfo(CCTMXMapInfo mapInfo)
        {
            MapInfo = mapInfo;
            MapSize = mapInfo.MapSize;
            TileSize = mapInfo.TileSize;
            MapOrientation = mapInfo.Orientation;
            ObjectGroups = mapInfo.ObjectGroups;
            Properties = mapInfo.Properties;
            TileProperties = mapInfo.TileProperties;

            int idx = 0;

            List<CCTMXLayerInfo> layers = mapInfo.Layers;
            if (layers != null && layers.Count > 0)
            {
                foreach(CCTMXLayerInfo layerInfo in layers)
                {
                    if (layerInfo.Visible)
                    {
                        CCTMXLayer child = ParseLayer(layerInfo, mapInfo);
                        AddChild(child, idx, idx);

                        // update content size with the max size
                        CCSize childSize = child.ContentSize;
                        CCSize currentSize = ContentSize;
                        currentSize.Width = Math.Max(currentSize.Width, childSize.Width);
                        currentSize.Height = Math.Max(currentSize.Height, childSize.Height);
                        ContentSize = currentSize;

                        idx++;
                    }
                }
            }
        }
예제 #11
0
        public void EndElement(object ctx, string elementName)
        {
            CCTMXMapInfo pTMXMapInfo = this;

            byte[] encoded = null;

            if (elementName == "data" && (pTMXMapInfo.LayerAttribs & (int)CCTMXLayerAttrib.Base64) != 0)
            {
                pTMXMapInfo.StoringCharacters = false;

                List <CCTMXLayerInfo> layers = pTMXMapInfo.Layers;
                int            layersCount   = layers != null ? layers.Count : 0;
                CCTMXLayerInfo layer         = layersCount > 0 ? layers[layersCount - 1] : null;

                if ((pTMXMapInfo.LayerAttribs & ((int)(CCTMXLayerAttrib.Gzip) | (int)CCTMXLayerAttrib.Zlib)) != 0)
                {
                    //gzip compress
                    if ((pTMXMapInfo.LayerAttribs & (int)CCTMXLayerAttrib.Gzip) != 0)
                    {
                        try
                        {
                            encoded = ZipUtils.Inflate(new MemoryStream(pTMXMapInfo.CurrentString), ZipUtils.CompressionFormat.Gzip);
                        }
                        catch (Exception ex)
                        {
                            CCLog.Log("failed to decompress embedded data object in TMX file.");
                            CCLog.Log(ex.ToString());
                        }
                    }

                    //zlib
                    if ((pTMXMapInfo.LayerAttribs & (int)CCTMXLayerAttrib.Zlib) != 0)
                    {
                        encoded = ZipUtils.Inflate(new MemoryStream(pTMXMapInfo.CurrentString), ZipUtils.CompressionFormat.Zlib);
                    }
                }
                else
                {
                    encoded = pTMXMapInfo.CurrentString;
                }

                for (int i = 0; i < layer.Tiles.Length; i++)
                {
                    int i4  = i * 4;
                    var gid = (uint)(
                        encoded[i4] |
                        encoded[i4 + 1] << 8 |
                            encoded[i4 + 2] << 16 |
                            encoded[i4 + 3] << 24);

                    layer.Tiles[i] = gid;
                }

                pTMXMapInfo.CurrentString = null;
            }
            else if (elementName == "map")
            {
                // The map element has ended
                pTMXMapInfo.ParentElement = (int)CCTMXProperty.None;
            }
            else if (elementName == "layer")
            {
                // The layer element has ended
                pTMXMapInfo.ParentElement = (int)CCTMXProperty.None;
            }
            else if (elementName == "objectgroup")
            {
                // The objectgroup element has ended
                pTMXMapInfo.ParentElement = (int)CCTMXProperty.None;
            }
            else if (elementName == "object")
            {
                // The object element has ended
                pTMXMapInfo.ParentElement = (int)CCTMXProperty.None;
            }
        }
예제 #12
0
        CCTMXLayer ParseLayer(CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo)
        {
            CCTMXTilesetInfo tileset = TilesetForLayer(layerInfo, mapInfo);
            CCTMXLayer layer = new CCTMXLayer(tileset, layerInfo, mapInfo);

            // tell the layerinfo to release the ownership of the tiles map.
            layerInfo.OwnTiles = false;
            layer.SetupTiles();

            return layer;
        }
예제 #13
0
 CCTMXLayer(CCTMXTilesetInfo tileSetInfo, CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo, CCSize layerSize, int totalNumberOfTiles)
     : this(tileSetInfo, layerInfo, mapInfo, layerSize, totalNumberOfTiles, (int)(totalNumberOfTiles * 0.35f + 1),
            CCTextureCache.SharedTextureCache.AddImage(tileSetInfo.SourceImage))
 {
 }
예제 #14
0
        // Private constructor chaining

        CCTMXLayer(CCTMXTilesetInfo tileSetInfo, CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo, CCSize layerSize)
            : this(tileSetInfo, layerInfo, mapInfo, layerSize, (int)(layerSize.Width * layerSize.Height))
        {
        }
예제 #15
0
 public CCTMXLayer(CCTMXTilesetInfo tileSetInfo, CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo)
     : this(tileSetInfo, layerInfo, mapInfo, layerInfo.LayerSize)
 {
 }
예제 #16
0
        CCTMXTilesetInfo TilesetForLayer(CCTMXLayerInfo layerInfo, CCTMXMapInfo mapInfo)
        {
            CCSize size = layerInfo.LayerSize;
            List<CCTMXTilesetInfo> tilesets = mapInfo.Tilesets;

            if (tilesets != null && tilesets.Count > 0)
            {
                for (int i = tilesets.Count - 1; i >= 0; i--)
                {
                    CCTMXTilesetInfo tileset = tilesets[i];
                    if (tileset != null)
                    {
                        for (int y = 0; y < size.Height; y++)
                        {
                            for (int x = 0; x < size.Width; x++)
                            {
                                var pos = (int) (x + size.Width * y);
                                uint gid = layerInfo.Tiles[pos];

                                // XXX: gid == 0 --> empty tile
                                if (gid != 0)
                                {
                                    // Optimization: quick return
                                    // if the layer is invalid (more than 1 tileset per layer) an CCAssert will be thrown later
                                    if ((gid & CCTMXTileFlags.FlippedMask) >= tileset.FirstGid)
                                    {
                                        return tileset;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // If all the tiles are 0, return empty tileset
            CCLog.Log("CocosSharp: Warning: TMX Layer '{0}' has no tiles", layerInfo.Name);
            return null;
        }
예제 #17
0
 public CCTMXTiledMap(CCTMXMapInfo mapInfo)
 {
     ContentSize = CCSize.Zero;
     BuildWithMapInfo(mapInfo);
 }
예제 #18
0
 public CCTMXTiledMap(CCTMXMapInfo mapInfo)
 {
     ContentSize = CCSize.Zero;
     BuildWithMapInfo(mapInfo);
 }
예제 #19
0
        public void StartElement(object ctx, string name, string[] atts)
        {
            CCTMXMapInfo pTMXMapInfo   = this;
            string       elementName   = name;
            var          attributeDict = new Dictionary <string, string>();

            if (atts != null && atts[0] != null)
            {
                for (int i = 0; i + 1 < atts.Length; i += 2)
                {
                    string key   = atts[i];
                    string value = atts[i + 1];
                    attributeDict.Add(key, value);
                }
            }

            if (elementName == "map")
            {
                string version = attributeDict["version"];
                if (version != "1.0")
                {
                    CCLog.Log("CocosSharp: TMXFormat: Unsupported TMX version: {0}", version);
                }
                string orientationStr = attributeDict["orientation"];
                if (orientationStr == "orthogonal")
                {
                    pTMXMapInfo.Orientation = (int)(CCTMXOrientation.Ortho);
                }
                else if (orientationStr == "isometric")
                {
                    pTMXMapInfo.Orientation = (int)(CCTMXOrientation.Iso);
                }
                else if (orientationStr == "hexagonal")
                {
                    pTMXMapInfo.Orientation = (int)(CCTMXOrientation.Hex);
                }
                else
                {
                    CCLog.Log("CocosSharp: TMXFomat: Unsupported orientation: {0}", pTMXMapInfo.Orientation);
                }

                CCSize sMapSize;
                sMapSize.Width      = CCUtils.CCParseFloat(attributeDict["width"]);
                sMapSize.Height     = CCUtils.CCParseFloat(attributeDict["height"]);
                pTMXMapInfo.MapSize = sMapSize;

                CCSize sTileSize;
                sTileSize.Width      = CCUtils.CCParseFloat(attributeDict["tilewidth"]);
                sTileSize.Height     = CCUtils.CCParseFloat(attributeDict["tileheight"]);
                pTMXMapInfo.TileSize = sTileSize;

                // The parent element is now "map"
                pTMXMapInfo.ParentElement = (int)CCTMXProperty.Map;
            }
            else if (elementName == "tileset")
            {
                // If this is an external tileset then start parsing that

                if (attributeDict.ContainsKey("source"))
                {
                    string externalTilesetFilename = attributeDict["source"];

                    externalTilesetFilename = CCFileUtils.FullPathFromRelativeFile(externalTilesetFilename,
                                                                                   pTMXMapInfo.TMXFileName);

                    currentFirstGID = uint.Parse(attributeDict["firstgid"]);

                    pTMXMapInfo.ParseXmlFile(externalTilesetFilename);
                }
                else
                {
                    var tileset = new CCTMXTilesetInfo();

                    tileset.Name = attributeDict["name"];

                    if (currentFirstGID == 0)
                    {
                        tileset.FirstGid = uint.Parse(attributeDict["firstgid"]);
                    }
                    else
                    {
                        tileset.FirstGid = currentFirstGID;
                        currentFirstGID  = 0;
                    }

                    if (attributeDict.ContainsKey("spacing"))
                    {
                        tileset.Spacing = int.Parse(attributeDict["spacing"]);
                    }

                    if (attributeDict.ContainsKey("margin"))
                    {
                        tileset.Margin = int.Parse(attributeDict["margin"]);
                    }

                    CCSize s;
                    s.Width          = CCUtils.CCParseFloat(attributeDict["tilewidth"]);
                    s.Height         = CCUtils.CCParseFloat(attributeDict["tileheight"]);
                    tileset.TileSize = s;

                    pTMXMapInfo.Tilesets.Add(tileset);
                }
            }
            else if (elementName == "tile")
            {
                List <CCTMXTilesetInfo> tilesets = pTMXMapInfo.Tilesets;
                int tilesetCount      = tilesets != null ? tilesets.Count : 0;
                CCTMXTilesetInfo info = tilesetCount > 0 ? tilesets[tilesetCount - 1] : null;
                var dict = new Dictionary <string, string>();
                pTMXMapInfo.ParentGID = (info.FirstGid + uint.Parse(attributeDict["id"]));
                pTMXMapInfo.TileProperties.Add(pTMXMapInfo.ParentGID, dict);

                pTMXMapInfo.ParentElement = (int)CCTMXProperty.Tile;
            }
            else if (elementName == "layer")
            {
                var layer = new CCTMXLayerInfo();
                layer.Name = attributeDict["name"];

                CCSize s;
                s.Width         = CCUtils.CCParseFloat(attributeDict["width"]);
                s.Height        = CCUtils.CCParseFloat(attributeDict["height"]);
                layer.LayerSize = s;

                layer.Tiles = new uint[(int)s.Width * (int)s.Height];

                if (attributeDict.ContainsKey("visible"))
                {
                    string visible = attributeDict["visible"];
                    layer.Visible = !(visible == "0");
                }
                else
                {
                    layer.Visible = true;
                }

                if (attributeDict.ContainsKey("opacity"))
                {
                    string opacity = attributeDict["opacity"];
                    layer.Opacity = (byte)(255 * CCUtils.CCParseFloat(opacity));
                }
                else
                {
                    layer.Opacity = 255;
                }

                float x = attributeDict.ContainsKey("x") ? CCUtils.CCParseFloat(attributeDict["x"]) : 0;
                float y = attributeDict.ContainsKey("y") ? CCUtils.CCParseFloat(attributeDict["y"]) : 0;
                layer.Offset = new CCPoint(x, y);

                pTMXMapInfo.Layers.Add(layer);

                // The parent element is now "layer"
                pTMXMapInfo.ParentElement = (int)CCTMXProperty.Layer;
            }
            else if (elementName == "objectgroup")
            {
                var objectGroup = new CCTMXObjectGroup();
                objectGroup.GroupName = attributeDict["name"];

                CCPoint positionOffset = CCPoint.Zero;
                if (attributeDict.ContainsKey("x"))
                {
                    positionOffset.X = CCUtils.CCParseFloat(attributeDict["x"]) * pTMXMapInfo.TileSize.Width;
                }
                if (attributeDict.ContainsKey("y"))
                {
                    positionOffset.Y = CCUtils.CCParseFloat(attributeDict["y"]) * pTMXMapInfo.TileSize.Height;
                }
                objectGroup.PositionOffset = positionOffset;

                pTMXMapInfo.ObjectGroups.Add(objectGroup);

                // The parent element is now "objectgroup"
                pTMXMapInfo.ParentElement = (int)CCTMXProperty.ObjectGroup;
            }
            else if (elementName == "image")
            {
                List <CCTMXTilesetInfo> tilesets = pTMXMapInfo.Tilesets;
                int tilesetCount         = tilesets != null ? tilesets.Count : 0;
                CCTMXTilesetInfo tileset = tilesetCount > 0 ? tilesets[tilesetCount - 1] : null;

                // build full path
                string imagename = attributeDict["source"];
                tileset.SourceImage = CCFileUtils.FullPathFromRelativeFile(imagename, pTMXMapInfo.TMXFileName);
            }
            else if (elementName == "data")
            {
                string encoding    = attributeDict.ContainsKey("encoding") ? attributeDict["encoding"] : "";
                string compression = attributeDict.ContainsKey("compression") ? attributeDict["compression"] : "";

                if (encoding == "base64")
                {
                    int layerAttribs = pTMXMapInfo.LayerAttribs;
                    pTMXMapInfo.LayerAttribs      = layerAttribs | (int)CCTMXLayerAttrib.Base64;
                    pTMXMapInfo.StoringCharacters = true;

                    if (compression == "gzip")
                    {
                        layerAttribs             = pTMXMapInfo.LayerAttribs;
                        pTMXMapInfo.LayerAttribs = layerAttribs | (int)CCTMXLayerAttrib.Gzip;
                    }
                    else if (compression == "zlib")
                    {
                        layerAttribs             = pTMXMapInfo.LayerAttribs;
                        pTMXMapInfo.LayerAttribs = layerAttribs | (int)CCTMXLayerAttrib.Zlib;
                    }
                    Debug.Assert(compression == "" || compression == "gzip" || compression == "zlib", "TMX: unsupported compression method");
                }
                Debug.Assert(pTMXMapInfo.LayerAttribs != (int)CCTMXLayerAttrib.None,
                             "TMX tile map: Only base64 and/or gzip/zlib maps are supported");
            }
            else if (elementName == "object")
            {
                List <CCTMXObjectGroup> objectGroups = pTMXMapInfo.ObjectGroups;
                int objectGroupCount         = objectGroups != null ? objectGroups.Count : 0;
                CCTMXObjectGroup objectGroup = objectGroupCount > 0 ? objectGroups[objectGroupCount - 1] : null;

                // The value for "type" was blank or not a valid class name
                // Create an instance of TMXObjectInfo to store the object and its properties
                var dict = new Dictionary <string, string>();

                var pArray = new[] { "name", "type", "width", "height", "gid" };

                for (int i = 0; i < pArray.Length; i++)
                {
                    string key = pArray[i];
                    if (attributeDict.ContainsKey(key))
                    {
                        dict.Add(key, attributeDict[key]);
                    }
                }

                // But X and Y since they need special treatment
                // X

                int x = int.Parse(attributeDict["x"]) + (int)objectGroup.PositionOffset.X;
                dict.Add("x", x.ToString());

                int y = int.Parse(attributeDict["y"]) + (int)objectGroup.PositionOffset.Y;
                // Correct y position. (Tiled uses Flipped, cocos2d uses Standard)
                y = (int)(pTMXMapInfo.MapSize.Height * pTMXMapInfo.TileSize.Height) - y -
                    (attributeDict.ContainsKey("height") ? int.Parse(attributeDict["height"]) : 0);
                dict.Add("y", y.ToString());

                // Add the object to the objectGroup
                objectGroup.Objects.Add(dict);

                // The parent element is now "object"
                pTMXMapInfo.ParentElement = (int)CCTMXProperty.Object;
            }
            else if (elementName == "property")
            {
                if (pTMXMapInfo.ParentElement == (int)CCTMXProperty.None)
                {
                    CCLog.Log("TMX tile map: Parent element is unsupported. Cannot add property named '{0}' with value '{1}'",
                              attributeDict["name"], attributeDict["value"]);
                }
                else if (pTMXMapInfo.ParentElement == (int)CCTMXProperty.Map)
                {
                    // The parent element is the map
                    string value = attributeDict["value"];
                    string key   = attributeDict["name"];
                    pTMXMapInfo.Properties.Add(key, value);
                }
                else if (pTMXMapInfo.ParentElement == (int)CCTMXProperty.Layer)
                {
                    // The parent element is the last layer
                    List <CCTMXLayerInfo> layers = pTMXMapInfo.Layers;
                    int            layersCount   = layers != null ? layers.Count : 0;
                    CCTMXLayerInfo layer         = layersCount > 0 ? layers[layersCount - 1] : null;

                    string value = attributeDict["value"];
                    string key   = attributeDict["name"];
                    // Add the property to the layer
                    layer.Properties.Add(key, value);
                }
                else if (pTMXMapInfo.ParentElement == (int)CCTMXProperty.ObjectGroup)
                {
                    // The parent element is the last object group
                    List <CCTMXObjectGroup> objectGroups = pTMXMapInfo.ObjectGroups;
                    int objGroupsCount           = objectGroups != null ? objectGroups.Count : 0;
                    CCTMXObjectGroup objectGroup = objGroupsCount > 0 ? objectGroups[objGroupsCount - 1] : null;
                    string           value       = attributeDict["value"];
                    string           key         = attributeDict["name"];
                    objectGroup.Properties.Add(key, value);
                }
                else if (pTMXMapInfo.ParentElement == (int)CCTMXProperty.Object)
                {
                    // The parent element is the last object
                    List <CCTMXObjectGroup> objectGroups = pTMXMapInfo.ObjectGroups;
                    int objGroupsCount           = objectGroups != null ? objectGroups.Count : 0;
                    CCTMXObjectGroup objectGroup = objGroupsCount > 0 ? objectGroups[objGroupsCount - 1] : null;

                    List <Dictionary <string, string> > objects = objectGroup.Objects;
                    int objCount = objects != null ? objects.Count : 0;
                    Dictionary <string, string> dict = objCount > 0 ? objects[objCount - 1] : null;

                    string propertyName  = attributeDict["name"];
                    string propertyValue = attributeDict["value"];
                    dict.Add(propertyName, propertyValue);
                }
                else if (pTMXMapInfo.ParentElement == (int)CCTMXProperty.Tile)
                {
                    Dictionary <string, string> dict = pTMXMapInfo.TileProperties[pTMXMapInfo.ParentGID];

                    string propertyName  = attributeDict["name"];
                    string propertyValue = attributeDict["value"];
                    dict.Add(propertyName, propertyValue);
                }
            }
            else if (elementName == "polygon")
            {
                // find parent object's dict and add polygon-points to it
                int objGroupsCount           = ObjectGroups != null ? ObjectGroups.Count : 0;
                CCTMXObjectGroup objectGroup = objGroupsCount > 0 ? ObjectGroups[objGroupsCount - 1] : null;

                List <Dictionary <string, string> > objects = objectGroup.Objects;
                int objCount = objects != null ? objects.Count : 0;
                Dictionary <string, string> dict = objCount > 0 ? objects[objCount - 1] : null;

                // get points value string
                var value = attributeDict["points"];
                if (!String.IsNullOrEmpty(value))
                {
                    var pPointsArray = new List <CCPoint>();
                    var pointPairs   = value.Split(' ');

                    foreach (var pontPair in pointPairs)
                    {
                        //TODO: Parse points
                        //CCPoint point;
                        //point.X = x + objectGroup.PositionOffset.X;
                        //point.Y = y + objectGroup.PositionOffset.Y;

                        //pPointsArray.Add(point);
                    }

                    //dict.Add("points", pPointsArray);
                }
            }
            else if (elementName == "polyline")
            {
                // find parent object's dict and add polyline-points to it
                // CCTMXObjectGroup* objectGroup = (CCTMXObjectGroup*)ObjectGroups->lastObject();
                // CCDictionary* dict = (CCDictionary*)objectGroup->getObjects()->lastObject();
                // TODO: dict->setObject:[attributeDict objectForKey:@"points"] forKey:@"polylinePoints"];
            }
        }