示例#1
0
        /// <summary>
        /// Loads a .tmx map and converts it to a TileMap.
        /// </summary>
        /// <param name="mapName"> The name of the map to load. </param>
        /// <param name="game"> The game. </param>
        /// <returns>
        /// A TileMap based on the .tmx map.
        /// </returns>
        public Map LoadTmxMap(string mapName, Game1 game)
        {
            // Finds the path to the map.
            var filename = Path.Combine(Directories.GetMapDirection(), mapName);

            this.tilesetList = new List<Tileset>();
            this.layerList = new List<MapLayer>();

            // Creates a new XmlDocument and loads the map in as one such.
            var document = new XmlDocument();
            document.Load(filename);

            XmlNode mapNode = document["map"];

            // Asserts that certain things exists in the XMLdocument.
            Debug.Assert(mapNode != null, "mapNode != null");
            Debug.Assert(mapNode.Attributes != null, "mapNode.Attributes != null");
            Debug.Assert(mapNode.FirstChild.Attributes != null, "mapNode.FirstChild.Attributes != null");

            // Finds the height and the width of the map.
            this.mapWidth = int.Parse(mapNode.Attributes["width"].Value, CultureInfo.InvariantCulture);
            this.mapHeight = int.Parse(mapNode.Attributes["height"].Value, CultureInfo.InvariantCulture);

            var xmlNodeList = document.SelectNodes("map/tileset");
            if (xmlNodeList != null)
            {
                // Loops through each node that describes a tileset.
                foreach (XmlNode tilesetNode in xmlNodeList)
                {
                    // Asserts that the tilesetNode contains attributes and that the
                    // first child contains attributes.
                    Debug.Assert(tilesetNode.Attributes != null, "tilesetNode.Attributes != null");
                    Debug.Assert(tilesetNode.FirstChild.Attributes != null, "tilesetNode.FirstChild.Attributes != null");

                    if (tilesetNode.FirstChild.Attributes["source"] != null)
                    {
                        // Loads the name, texture, height and width of the current tilesetNode.
                        var tilesetName = tilesetNode.Attributes["name"].Value;
                        var tilesetTexture = game.Content.Load<Texture2D>(@"Textures\TileSets\" + tilesetName);
                        var tilesWide = int.Parse(tilesetNode.FirstChild.Attributes["width"].Value)
                                        / int.Parse(tilesetNode.Attributes["tilewidth"].Value);
                        var tilesHigh = int.Parse(tilesetNode.FirstChild.Attributes["height"].Value)
                                        / int.Parse(tilesetNode.Attributes["tileheight"].Value);

                        // Makes a new tileset from the above variables.
                        var testset = new Tileset(
                            tilesetTexture,
                            tilesWide,
                            tilesHigh,
                            int.Parse(tilesetNode.Attributes["tilewidth"].Value),
                            int.Parse(tilesetNode.Attributes["tileheight"].Value));

                        // Sets the Firstgid value of the tilset to the value stored in the tilesetNode.
                        testset.SetFirstgid(int.Parse(tilesetNode.Attributes["firstgid"].Value));

                        // Adds the tileset to the list of tilesets that make up the map.
                        this.tilesetList.Add(testset);
                    }
                }
            }

            var selectNodes = document.SelectNodes("map/layer|map/objectgroup");
            if (selectNodes != null)
            {
                // Loops through each node that describes a layer in the XMLDocument
                foreach (XmlNode layerNode in selectNodes)
                {
                    if (layerNode.Name == "layer")
                    {
                        // Makes a layer from the node.
                        this.MakeLayer(layerNode);
                    }
                }
            }

            // Creates and returns a TileMap based on the list of tilesets and maplayers.
            return new Map(this.tilesetList, this.layerList);
        }
示例#2
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Map"/> class.
        /// </summary>
        /// <param name="tileset"> The tileset to create the map from. </param>
        /// <param name="layer"> The layer to create the map from. </param>
        public Map(Tileset tileset, MapLayer layer)
        {
            this.tilesets = new List<Tileset>();
            this.tilesets.Add(tileset);

            this.mapLayers = new List<MapLayer>();
            this.mapLayers.Add(layer);

            mapWidth = this.mapLayers[0].Width;
            mapHeight = this.mapLayers[0].Height;

            this.dataMap = new MapData(this.MapHeight, this.MapWidth);
            this.dataMap.AddCollision(this.mapLayers, this.tilesets);
        }
示例#3
0
        /// <summary>
        /// Makes a layer for the map from the given input.
        /// </summary>
        /// <param name="lines"> The lines that holds the data for the map. </param>
        /// <param name="start"> The line to start reading from. </param>
        /// <param name="height"> The height of the map. </param>
        /// <param name="width"> The width of the map. </param>
        /// <param name="gameRef"> A snapshot of the game. </param>
        private void MakeLayer(string[] lines, int start, int height, int width, Game1 gameRef)
        {
            // Finds the name of the tileset used to make this specific layer and loads it.
            var tilesetName = lines[start + 2].Substring(lines[start + 2].IndexOf('=') + 1);
            var tilesetTexture = gameRef.Content.Load<Texture2D>(@"Textures\TileSets\" + tilesetName);
            var backgroundTileset = new Tileset(
                tilesetTexture, tilesetTexture.Width / 32, tilesetTexture.Height / 32, 32, 32);
            this.tilesets.Add(backgroundTileset);

            var index = lines[start + 1].IndexOf('=') + 1;

            var layerName = lines[start + 1].Substring(index, lines[start + 1].Length - index);

            var background = new MapLayer(layerName, width, height);

            // Goes through all the lines that hold tileIDs
            for (int i = 0; i < height; i++)
            {
                // Loads the current line and splits it into a string array.
                string[] stringTileIDs = lines[i + start + 4].Split(',');
                var tileIDs = new int[width];

                // Converts each ID from a string to an int.
                for (int j = 0; j < width; j++)
                {
                    tileIDs[j] = Convert.ToInt32(stringTileIDs[j]);
                }

                // Loops through the list of TileIDs and places new tiles in the layer, corrosponding
                // to the ID and position.
                for (int j = 0; j < width; j++)
                {
                    background.SetTile(i, j, new Tile(tileIDs[j] - 1 < 0 ? 0 : tileIDs[j] - 1, this.tilesets.Count - 1));
                }
            }

            this.layers.Add(background);
        }