/// <summary> /// Converts basic tilesets into collider tilesets using data from Tiled structures. /// </summary> ITilesetTile[] ConvertTiles(TiledMapTileset tiledTileset, Tileset tileset) { var tilesetTiles = new List <ITilesetTile>(); for (var i = 0; i < tileset.Tiles.Length; i += 1) { var tiledTile = tiledTileset.Tiles[i]; // Getting solid property from the tile. var solid = false; try { solid = bool.Parse(tiledTile.Properties["Solid"]); } catch (Exception) {} // Getting solid property from the tile. SolidTilesetTile tilesetTile; tilesetTile = new SolidTilesetTile(tileset.Tiles[i].Frame, solid); tilesetTiles.Add(tilesetTile); } return(tilesetTiles.ToArray()); }
/// <summary> /// Updates tilemap, e.g. when the current map has changed. /// </summary> public void UpdateTilemap() { string tiledMapFilename = this.CurrentMap.TiledMapFilename.Replace(".tmx", string.Empty); this.TileMap = this.contentManager.Load <TiledMap>(tiledMapFilename); this.ObjectTileset = this.contentManager.Load <TiledMapTileset>("tilemaps/objects"); this.mapVisibility = new MapVisibility(this.GetTileInfo, 5); }
/// <summary> /// Draws a single tile of given tileset and tileset index /// </summary> /// <param name="renderer">gui renderer</param> /// <param name="tileset">tileset to use</param> /// <param name="tileIndex">tile with given index into tileset</param> /// <param name="screenX">screen X coordinates of upper left corner of tile</param> /// <param name="screenY">screen Y coordinates of upper left corner of tile</param> private void DrawTilesetTile(IGuiRenderer renderer, TiledMapTileset tileset, int tileIndex, int screenX, int screenY) { var tileSize = new Vector2( (float)this.Width / this.sizeInTiles.X, (float)this.Height / this.sizeInTiles.Y); var destinationRectangle = new Rectangle( this.Position.X + (int)(screenX * tileSize.X), this.Position.Y + (int)(screenY * tileSize.Y), (int)(tileSize.X + 0.5), (int)(tileSize.Y + 0.5)); renderer.DrawRegion( tileset.GetRegion(tileIndex % tileset.Columns, tileIndex / tileset.Columns), destinationRectangle, Color.White); }
void ReadTilesets(ContentReader input, TiledMap map) { var tilesetsCount = input.ReadInt32(); var tilesets = new TiledMapTileset[tilesetsCount]; for (var i = 0; i < tilesetsCount; i += 1) { tilesets[i] = new TiledMapTileset(); tilesets[i].Name = input.ReadString(); tilesets[i].TexturePaths = input.ReadObject <string[]>(); if (input.ReadBoolean()) { var texturesCount = input.ReadInt32(); tilesets[i].Textures = new Texture2D[texturesCount]; for (var k = 0; k < texturesCount; k += 1) { var path = Path.Combine(Path.GetDirectoryName(input.AssetName), input.ReadString()); tilesets[i].Textures[k] = input.ContentManager.Load <Texture2D>(path); } } tilesets[i].FirstGID = input.ReadInt32(); tilesets[i].TileWidth = input.ReadInt32(); tilesets[i].TileHeight = input.ReadInt32(); tilesets[i].Spacing = input.ReadInt32(); tilesets[i].Margin = input.ReadInt32(); tilesets[i].TileCount = input.ReadInt32(); tilesets[i].Columns = input.ReadInt32(); tilesets[i].Offset = input.ReadVector2(); var tiles = new TiledMapTilesetTile[tilesets[i].TileCount]; for (var k = 0; k < tiles.Length; k += 1) { tiles[k] = ReadTilesetTile(input, map); tiles[k].Tileset = tilesets[i]; } tilesets[i].Tiles = tiles; tilesets[i].BackgroundColor = input.ReadObject <Color?>(); tilesets[i].Properties = input.ReadObject <Dictionary <string, string> >(); } map.Tilesets = tilesets; }
/// <summary> /// Converts basic tilesets into collider tilesets using data from Tiled structures. /// </summary> ITilesetTile[] ConvertTiles(TiledMapTileset tiledTileset, Tileset tileset) { var tilesetTiles = new List <ITilesetTile>(); for (var i = 0; i < tileset.Tiles.Length; i += 1) { var tiledTile = tiledTileset.Tiles[i]; // Getting collision mode of a tile. var mode = TilesetTileCollisionMode.None; try { mode = (TilesetTileCollisionMode)Enum.Parse(typeof(TilesetTileCollisionMode), tiledTile.Properties[_typeProperty]); } catch (Exception) {} // Getting collision mode of a tile. ColliderTilesetTile tilesetTile; if (mode == TilesetTileCollisionMode.Custom) { // Getting custom collider. var colliderOffset = Vector2.Zero; var collider = GetCollider(tiledTile, tileset, ref colliderOffset); // Getting custom collider. tilesetTile = new ColliderTilesetTile(tileset.Tiles[i].Frame, mode, collider, colliderOffset); } else { // No need to bother with getting custom colliders here. tilesetTile = new ColliderTilesetTile(tileset.Tiles[i].Frame, mode); } tilesetTiles.Add(tilesetTile); } return(tilesetTiles.ToArray()); }
static TiledMapTileset ParseTileset(XmlNode tilesetXml) { var tileset = new TiledMapTileset(); tileset.FirstGID = int.Parse(tilesetXml.Attributes["firstgid"].Value); var tilesetDir = ""; if (tilesetXml.Attributes["source"] != null) { ExternalTilesetsFirstGID.Add( Path.GetFullPath(TiledMapImporter.CurrentRootDir + '/' + tilesetXml.Attributes["source"].Value), (uint)tileset.FirstGID ); // If there is "source" field, that means, tileset is external. var doc = new XmlDocument(); try { // Paths in tileset file are relative to that file, so root dir needs to be swapped. TiledMapImporter.CurrentRootDir = TiledMapImporter.TmxRootDir + Path.GetDirectoryName(tilesetXml.Attributes["source"].Value) + "/"; doc.Load(TiledMapImporter.CurrentRootDir + "/" + Path.GetFileName(tilesetXml.Attributes["source"].Value)); tilesetDir = Path.GetDirectoryName(tilesetXml.Attributes["source"].Value) + '/'; tilesetXml = doc["tileset"]; // Swapping to actual tileset. } catch (Exception e) { throw new Exception("Error loading external tileset! " + e.Message + " " + e.StackTrace); } } tileset.Properties = XmlHelper.GetProperties(tilesetXml); // This means, that tileset won't be used in the game and should be ignored. if ( tileset.Properties.ContainsKey(IgnoreTilesetFlag) && bool.Parse(tileset.Properties[IgnoreTilesetFlag]) ) { TiledMapImporter.CurrentRootDir = TiledMapImporter.TmxRootDir; return(null); } Logger.Log("Parsing tileset " + tilesetXml.Attributes["name"].Value); #region Main fields. tileset.Name = tilesetXml.Attributes["name"].Value; tileset.TileWidth = int.Parse(tilesetXml.Attributes["tilewidth"].Value); tileset.TileHeight = int.Parse(tilesetXml.Attributes["tileheight"].Value); tileset.TileCount = int.Parse(tilesetXml.Attributes["tilecount"].Value); tileset.Columns = int.Parse(tilesetXml.Attributes["columns"].Value); tileset.Margin = XmlHelper.GetXmlIntSafe(tilesetXml, "margin"); tileset.Spacing = XmlHelper.GetXmlIntSafe(tilesetXml, "spacing"); if (tilesetXml.Attributes["backgroundcolor"] != null) { tileset.BackgroundColor = XmlHelper.StringToColor(tilesetXml.Attributes["backgroundcolor"].Value); } if (tilesetXml["tileoffset"] != null) { tileset.Offset = new Vector2( float.Parse(tilesetXml["tileoffset"].Attributes["x"].Value, CultureInfo.InvariantCulture), float.Parse(tilesetXml["tileoffset"].Attributes["y"].Value, CultureInfo.InvariantCulture) ); } #endregion Main fields. // Turning tile xml into usable dictionary. var tiles = new Dictionary <int, XmlNode>(); // List won't suit, because some tile ids may be skipped. foreach (XmlNode tileXml in tilesetXml.SelectNodes("tile")) { tiles.Add(int.Parse(tileXml.Attributes["id"].Value), tileXml); } // Turning tile xml into usable dictionary. /* * It is very problematic to load Texture2D without * GraphicsDevice, so textures are imported later as external references. * At this stage map will just remember their * relative paths, and will pick textures up later. */ tileset.Tiles = new TiledMapTilesetTile[tileset.TileCount]; if (tilesetXml["image"] != null) { /* * NOTE: Single image tilesets can still have * <tile> tags with properties. */ // Single-image tileset. var texturePaths = new string[1]; texturePaths[0] = tilesetDir + tilesetXml["image"].Attributes["source"].Value; tileset.TexturePaths = texturePaths; var currentID = 0; for (var y = 0; y < tileset.Height; y += 1) { for (var x = 0; x < tileset.Width; x += 1) { var tile = new TiledMapTilesetTile(); //tile.Tileset = tileset; // Assigning tileset here is useless - loopback link will be lost during serialization. tile.GID = tileset.FirstGID + currentID; tile.TextureID = 0; tile.TexturePosition = new Rectangle( tileset.Margin + x * (tileset.TileWidth + tileset.Spacing), tileset.Margin + y * (tileset.TileHeight + tileset.Spacing), tileset.TileWidth, tileset.TileHeight ); if (tiles.ContainsKey(currentID)) { ReadTileObjects(tiles[currentID], ref tile); tile.Properties = XmlHelper.GetProperties(tiles[currentID]); } else { tile.Objects = new TiledObject[0]; tile.Properties = new Dictionary <string, string>(); } tileset.Tiles[currentID] = tile; currentID += 1; } } // Single-image tileset. } else { // Image collection tileset. var texturePaths = new List <string>(); var currentID = 0; foreach (var nodePair in tiles) { var tile = new TiledMapTilesetTile(); //tile.Tileset = tileset; tile.GID = tileset.FirstGID + nodePair.Key; var texturePath = tilesetDir + nodePair.Value["image"].Attributes["source"].Value; if (texturePaths.Contains(texturePath)) { // Avoiding duplicates. tile.TextureID = texturePaths.IndexOf(texturePath); } else { tile.TextureID = texturePaths.Count; texturePaths.Add(texturePath); } tile.TexturePosition = new Rectangle( 0, 0, int.Parse(nodePair.Value["image"].Attributes["width"].Value), int.Parse(nodePair.Value["image"].Attributes["height"].Value) ); ReadTileObjects(nodePair.Value, ref tile); tile.Properties = XmlHelper.GetProperties(nodePair.Value); tileset.Tiles[currentID] = tile; currentID += 1; } tileset.TexturePaths = texturePaths.ToArray(); // Image collection tileset. } TiledMapImporter.CurrentRootDir = TiledMapImporter.TmxRootDir; return(tileset); }
public GameMap(TiledMap tiledMap) { TiledMap = tiledMap; tiles = new Tile[tiledMap.Width, tiledMap.Height]; foreach (var layer in tiledMap.TileLayers) { for (int x = 0; x < layer.Width; x++) { for (int y = 0; y < layer.Height; y++) { if (tiles[x, y] == null) { tiles[x, y] = new Tile(this, x, y); } layer.TryGetTile(x, y, out TiledMapTile? tiledMapTile); TiledMapTile layerTile = tiledMapTile.Value; if (layerTile.IsBlank) { continue; } TiledMapTileset tileset = TiledMap.GetTilesetByTileGlobalIdentifier(layerTile.GlobalIdentifier); TiledMapTilesetTile tilesetTile = tileset.Tiles.FirstOrDefault( t => t.LocalTileIdentifier == layerTile.GlobalIdentifier - tileset.FirstGlobalIdentifier); if (tilesetTile != null) { tilesetTile.Properties.TryGetValue("IsWalkable", out string isWalkable); tilesetTile.Properties.TryGetValue("IsPlaceable", out string isPlaceable); tilesetTile.Properties.TryGetValue("IsSpawnable", out string isSpawnable); tiles[x, y].IsWalkable = isWalkable == "true"; tiles[x, y].IsPlaceable = isPlaceable == "true"; tiles[x, y].IsSpawnable = isSpawnable == "true"; if (tiles[x, y].IsSpawnable) { spawnableTiles.Add(tiles[x, y]); } } } } } // Store references to each tile's adjacent tiles. foreach (var tile in tiles) { if (tile.Position.X > 0) { tile.AdjacentTiles.Add(this[tile.X - 1, tile.Y]); } if (tile.Position.X < TiledMap.Width - 1) { tile.AdjacentTiles.Add(this[tile.X + 1, tile.Y]); } if (tile.Position.Y > 0) { tile.AdjacentTiles.Add(this[tile.X, tile.Y - 1]); } if (tile.Position.Y < TiledMap.Height - 1) { tile.AdjacentTiles.Add(this[tile.X, tile.Y + 1]); } } }
/// <summary> /// Draws single tile /// </summary> /// <param name="tileIndex">tile with given index into tilemap tileset</param> /// <param name="screenX">screen X coordinates of upper left corner of tile</param> /// <param name="screenY">screen Y coordinates of upper left corner of tile</param> private void DrawTile(IGuiRenderer renderer, int tileIndex, int screenX, int screenY) { TiledMapTileset tileset = this.viewModel.TileMap.Tilesets.First(); this.DrawTilesetTile(renderer, tileset, tileIndex, screenX, screenY); }
protected void SetTilesFromTiledMap(TiledMap tiledMap) { Tiles = new List <Tile>(); List <TiledMapTile> tiledMapTiles = tiledMap.TileLayers.FirstOrDefault().Tiles.ToList(); TiledMapTileset tiledMapTileset = tiledMap.Tilesets.FirstOrDefault(); List <TiledMapTilesetTile> tiledMapTilesetTiles = tiledMapTileset.Tiles.ToList(); var test = tiledMapTiles.Where(t => t.GlobalIdentifier != 0).ToList(); int textureColumns = tiledMapTileset.Columns; Texture2D tilesetTexture = tiledMap.Tilesets.FirstOrDefault().Texture; int? rows = tiledMap.TileLayers.FirstOrDefault().Height; int? columns = tiledMap.TileLayers.FirstOrDefault().Width; int i = 0; for (int y = 0; y < rows; y++) { for (int x = 0; x < columns; x++) { TiledMapTile tiledMapTile = tiledMapTiles[i]; Tile tile = new Tile { Container = this, Location = new Point(x, y), CollisionType = CollisionType.None, TileType = (TileType)tiledMapTile.GlobalIdentifier, MaxHealth = 0, CurrentHealth = 0, North = y == 0 ? null : columns * y - columns + x, NorthEast = y == 0 || x == columns - 1 ? null : columns * y - columns + x + 1, East = x == columns - 1 ? null : (int?)Tiles.Count() + 1, SouthEast = y == rows - 1 || x == columns - 1 ? null : columns * y + columns + x + 1, South = y == rows - 1 ? null : columns * y + columns + x, SouthWest = y == rows - 1 || x == 0 ? null : columns * y + columns + x - 1, West = x == 0 ? null : (int?)Tiles.Count() - 1, NorthWest = y == 0 || x == 0 ? null : columns * y - columns + x - 1, }; tile.Position = new Vector2(x * MainGame.TileSize, y * MainGame.TileSize) - Center + tile.TileCenter; Vector2 relativePosition = new Vector2(x * MainGame.TileSize, y * MainGame.TileSize); relativePosition -= Center; tile.Bounds = new Rectangle((int)relativePosition.X, (int)relativePosition.Y, MainGame.TileSize, MainGame.TileSize); // Set Image Data if (tiledMapTile.GlobalIdentifier > 0) { tile.Image = tilesetTexture; tile.ImageSource = new Rectangle( ((tiledMapTile.GlobalIdentifier - 1) % textureColumns) * Art.TileSize, ((tiledMapTile.GlobalIdentifier - 1) / textureColumns - 1 < 0 ? 0 : (tiledMapTile.GlobalIdentifier - 1) / textureColumns) * Art.TileSize, Art.TileSize, Art.TileSize); tile.Heading = tiledMapTile.IsFlippedDiagonally && tiledMapTile.IsFlippedHorizontally ? (float)Math.PI / 2 : tiledMapTile.IsFlippedDiagonally && tiledMapTile.IsFlippedVertically ? -(float)Math.PI / 2 : tiledMapTile.IsFlippedVertically ? (float)Math.PI : 0; } // Set Tileset Data TiledMapTilesetTile tiledMapTilesetTile = tiledMapTilesetTiles.FirstOrDefault(t => t.LocalTileIdentifier + 1 == tiledMapTile.GlobalIdentifier); if (tiledMapTilesetTile != null) { tile.CollisionType = tiledMapTilesetTile.Properties.ContainsKey("Collision") ? (CollisionType)int.Parse(tiledMapTilesetTile.Properties["Collision"]) : CollisionType.None; tile.MaxHealth = tiledMapTilesetTile.Properties.ContainsKey("Health") ? int.Parse(tiledMapTilesetTile.Properties["Health"]) : 0; tile.CurrentHealth = tile.MaxHealth; } Tiles.Add(tile); i++; } } }