/// <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++;
}
}
}
