/// <summary>
/// Creates a new Tile object.
/// </summary>
/// <param name="texture">The texture that contains the tile image.</param>
/// <param name="source">The source rectangle of the tile.</param>
/// <param name="properties">The initial property collection or null to create an empty property collection.</param>
public Tile(TileSet tileSet, Rect source, int GID, PropertyCollection properties)
{
if (tileSet == null)
throw new ArgumentNullException("tileSet");
this.GID = GID;
TileSet = tileSet;
Source = source;
Properties = properties ?? new PropertyCollection();
Color = Color.white;
//SpriteEffects = SpriteEffects.None;
}
/// <summary>
/// Creates a new Tile object.
/// </summary>
/// <param name="texture">The texture that contains the tile image.</param>
/// <param name="source">The source rectangle of the tile.</param>
/// <param name="properties">The initial property collection or null to create an empty property collection.</param>
public Tile(TileSet tileSet, Rect source, int GID, PropertyCollection properties)
{
if (tileSet == null)
throw new ArgumentNullException("tileSet");
this.GID = GID;
TileSet = tileSet;
Source = source;
Properties = properties ?? new PropertyCollection();
Color = Color.white;
//SpriteEffects = SpriteEffects.None;
// Create Sprite
TileSprite = Sprite.Create(TileSet.Texture, Source, Vector2.zero, TileSet.TileWidth, (uint)(TileSet.Spacing * 2));
TileSprite.name = GID.ToString();
}
/// <summary>
/// Creates a new Tile object.
/// </summary>
/// <param name="tileSet">The TileSet that contains the tile image.</param>
/// <param name="source">The source rectangle of the tile.</param>
/// <param name="OriginalID">This Tile's ID</param>
/// <param name="properties">The initial property collection or null to create an empty property collection.</param>
/// <param name="pivot">The Tile's Sprite Pivot Point</param>
/// <param name="mapTileWidth">The Map's TileWidth this tile is inside, used to calculate sprite's pixelsToUnits</param>
public Tile(TileSet tileSet, Rect source, int OriginalID, PropertyCollection properties, Vector2 pivot, int mapTileWidth = 0)
{
if (tileSet == null)
throw new ArgumentNullException("tileSet");
this.OriginalID = OriginalID;
CurrentID = OriginalID;
TileSet = tileSet;
Source = source;
Properties = properties ?? new PropertyCollection();
Color = Color.white;
SpriteEffects = new X_UniTMX.SpriteEffects();
MapTileWidth = mapTileWidth;
if (mapTileWidth <= 0)
MapTileWidth = TileSet.TileWidth;
CreateSprite(pivot);
}
/// <summary>
/// Creates a new Tile without creating the Sprite
/// </summary>
/// <param name="tileSet">The TileSet that contains the tile image.</param>
/// <param name="source">The source rectangle of the tile.</param>
/// <param name="OriginalID">This Tile's ID</param>
/// <param name="properties">The initial property collection or null to create an empty property collection.</param>
internal Tile(TileSet tileSet, Rect source, int OriginalID, PropertyCollection properties, int mapTileWidth = 0)
{
this.OriginalID = OriginalID;
CurrentID = OriginalID;
TileSet = tileSet;
Source = source;
Properties = properties ?? new PropertyCollection();
Color = Color.white;
SpriteEffects = new X_UniTMX.SpriteEffects();
if (mapTileWidth <= 0)
MapTileWidth = TileSet.TileWidth;
}
/// <summary>
/// Creates a new Tile object.
/// </summary>
/// <param name="tileSet">The TileSet that contains the tile image.</param>
/// <param name="source">The source rectangle of the tile.</param>
/// <param name="OriginalID">This Tile's ID</param>
public Tile(TileSet tileSet, Rect source, int OriginalID)
: this(tileSet, source, OriginalID, new PropertyCollection(), Vector2.zero)
{
}
Vector3 GetTileWorldPosition(int tileX, int tileY, TileSet tileSet)
{
Vector3 pos = Vector3.zero;
// Set Tile's position according to map orientation
// Can't use Map.TiledPositionToWorldPoint as sprites' anchors doesn't follow tile anchor point
if (BaseMap.Orientation == Orientation.Orthogonal)
{
//pos = new Vector3(
// tileX * (BaseMap.TileWidth / (float)tileSet.TileWidth),
// (-tileY - 1) * (BaseMap.TileHeight / (float)tileSet.TileHeight) * ((float)tileSet.TileHeight / (float)tileSet.TileWidth),
// 0);
float ratio = tileSet.TileHeight / (float)tileSet.TileWidth;
float mapRatio = BaseMap.TileHeight / (float)BaseMap.TileWidth;
pos = new Vector3(tileX, 1, 0);
if(ratio != 1)
pos.y = (-tileY - 1) * (BaseMap.TileHeight / (float)tileSet.TileHeight) * ratio;
else
pos.y = (-tileY - 1) * mapRatio;
}
else if (BaseMap.Orientation == Orientation.Isometric)
{
pos = new Vector3(
(BaseMap.TileWidth / 2.0f * (BaseMap.Width - tileY + tileX) - tileSet.TileWidth / 2.0f) / (float)BaseMap.TileWidth,
-BaseMap.Height + BaseMap.TileHeight * (BaseMap.Height - ((tileX + tileY) / (BaseMap.TileWidth / (float)BaseMap.TileHeight)) / 2.0f) / (float)BaseMap.TileHeight - (BaseMap.TileHeight / (float)BaseMap.TileWidth),
0);
}
else if (BaseMap.Orientation == Orientation.Staggered)
{
// In Staggered maps, odd rows and even rows are handled differently
if (tileY % 2 < 1)
{
// Even row
pos.x = tileX * (BaseMap.TileWidth / (float)tileSet.TileWidth);
pos.y = (-tileY - 2) * (BaseMap.TileHeight / 2.0f / (float)tileSet.TileHeight) * ((float)tileSet.TileHeight / (float)tileSet.TileWidth);
}
else
{
// Odd row
pos.x = tileX * (BaseMap.TileWidth / (float)tileSet.TileWidth) + (BaseMap.TileWidth / (float)tileSet.TileWidth) / 2.0f;
pos.y = (-tileY - 2) * (BaseMap.TileHeight / 2.0f / (float)tileSet.TileHeight) * ((float)tileSet.TileHeight / (float)tileSet.TileWidth);
}
}
// Add TileSet Tile Offset
pos.x += tileSet.TileOffsetX / (float)BaseMap.TileWidth;
pos.y += tileSet.TileOffsetY / (float)BaseMap.TileWidth;
return pos;
}
/// <summary>
/// Sets a Tile in position x and y to be Tile with ID equals newTileID (a Local Tile ID from tileSet)
/// This does not works if the layer is not made of Unique Tiles.
/// </summary>
/// <param name="x">Tile X index</param>
/// <param name="y">Tile Y index</param>
/// <param name="newTileID">Local Tile ID to change existing tile to. If -1 is passed, erase current Tile</param>
/// <param name="tileSet">TileSet to read newTileID from</param>
/// <returns>true if newTileID inside tileSet was found and change succeded, false otherwise</returns>
public bool SetTile(float x, float y, int newTileID, TileSet tileSet)
{
return SetTile(Mathf.FloorToInt(x), Mathf.FloorToInt(y), newTileID, tileSet);
}
/// <summary>
/// Creates a new Tile object.
/// </summary>
/// <param name="tileSet">The TileSet that contains the tile image.</param>
/// <param name="source">The source rectangle of the tile.</param>
/// <param name="OriginalID">This Tile's ID</param>
public Tile(TileSet tileSet, Rect source, int OriginalID) : this(tileSet, source, OriginalID, new PropertyCollection(), Vector2.zero)
{
}
void OnFinishedLoadingTileSet(TileSet tileSet)
{
TileSets.Add(tileSet);
foreach (KeyValuePair<int, Tile> item in tileSet.Tiles)
{
this.Tiles.Add(item.Key, item.Value);
}
_tileSetsToLoaded++;
if (_tileSetsToLoaded >= _numberOfTileSetsToLoad)
ContinueLoadingTiledMapAfterTileSetsLoaded();
}
/// <summary>
/// Creates a new Tile object.
/// </summary>
/// <param name="texture">The texture that contains the tile image.</param>
/// <param name="source">The source rectangle of the tile.</param>
public Tile(TileSet tileSet, Rect source, int GID) : this(tileSet, source, GID, new PropertyCollection())
{
}
Vector3 GetTileWorldPosition(int tileX, int tileY, TileSet tileSet)
{
Vector3 pos = Vector3.zero;
MapRenderParameters renderParam = BaseMap.MapRenderParameter;
// Set Tile's position according to map orientation
// Can't use Map.TiledPositionToWorldPoint as sprites' anchors doesn't follow tile anchor point
if (renderParam.Orientation == Orientation.Orthogonal)
{
//pos = new Vector3(
// tileX * (BaseMap.TileWidth / (float)tileSet.TileWidth),
// (-tileY - 1) * (BaseMap.TileHeight / (float)tileSet.TileHeight) * ((float)tileSet.TileHeight / (float)tileSet.TileWidth),
// 0);
float ratio = tileSet.TileHeight / (float)tileSet.TileWidth;
float mapRatio = renderParam.TileHeight / (float)renderParam.TileWidth;
pos.x = tileX;
if(ratio != 1)
pos.y = (-tileY - 1) * (renderParam.TileHeight / (float)tileSet.TileHeight) * ratio;
else
pos.y = (-tileY - 1) * mapRatio;
}
else if (renderParam.Orientation == Orientation.Isometric)
{
pos.x = (renderParam.TileWidth / 2.0f * (renderParam.Width - tileY + tileX) - tileSet.TileWidth / 2.0f) / (float)renderParam.TileWidth;
pos.y = -renderParam.Height + renderParam.TileHeight * (renderParam.Height - ((tileX + tileY) / (renderParam.TileWidth / (float)renderParam.TileHeight)) / 2.0f) / (float)renderParam.TileHeight - (renderParam.TileHeight / (float)renderParam.TileWidth);
}
else if (renderParam.Orientation == Orientation.Staggered)
{
// In Staggered maps, odd rows and even rows are handled differently
if (renderParam.MapStaggerAxis.Equals(StaggerAxis.Y))
{
if ((renderParam.MapStaggerIndex.Equals(StaggerIndex.Odd) && tileY % 2 < 1) ||
(renderParam.MapStaggerIndex.Equals(StaggerIndex.Even) && tileY % 2 > 0))
{
// Even row in Odd Staggered Maps
// Odd row in Even Staggered Maps
pos.x = tileX * (renderParam.TileWidth / (float)tileSet.TileWidth);
pos.y = (-tileY - 2) * (renderParam.TileHeight / 2.0f / (float)tileSet.TileHeight) * ((float)tileSet.TileHeight / (float)tileSet.TileWidth);
}
else
{
// Odd row in Odd Staggered Maps
// Even row in Even Staggered Maps
pos.x = tileX * (renderParam.TileWidth / (float)tileSet.TileWidth) + (renderParam.TileWidth / (float)tileSet.TileWidth) / 2.0f;
pos.y = (-tileY - 2) * (renderParam.TileHeight / 2.0f / (float)tileSet.TileHeight) * ((float)tileSet.TileHeight / (float)tileSet.TileWidth);
}
}
else
{
if ((renderParam.MapStaggerIndex.Equals(StaggerIndex.Odd) && tileX % 2 < 1) ||
(renderParam.MapStaggerIndex.Equals(StaggerIndex.Even) && tileX % 2 > 0))
{
// Even row in Odd Staggered Maps
// Odd row in Even Staggered Maps
pos.x = tileX * (renderParam.TileWidth / 2.0f / (float)tileSet.TileWidth);
pos.y = (-tileY - 1) * (renderParam.TileHeight / (float)tileSet.TileHeight) * ((float)tileSet.TileHeight / (float)tileSet.TileWidth);
}
else
{
// Odd row in Odd Staggered Maps
// Even row in Even Staggered Maps
pos.x = tileX * (renderParam.TileWidth / 2.0f / (float)tileSet.TileWidth);
pos.y = (-tileY - 1) * (renderParam.TileHeight / (float)tileSet.TileHeight) * ((float)tileSet.TileHeight / (float)tileSet.TileWidth) - (BaseMap.MapRenderParameter.TileHeight / (float)tileSet.TileHeight) / 2.0f * ((float)tileSet.TileHeight / (float)tileSet.TileWidth);
}
}
}
else if (renderParam.Orientation == Orientation.Hexagonal)
{
// In Staggered maps, odd rows and even rows are handled differently
if (renderParam.MapStaggerAxis.Equals(StaggerAxis.Y))
{
float halfGap = (renderParam.TileHeight - renderParam.HexSideLength) / 2.0f;
float tileDisplacement = halfGap + renderParam.HexSideLength;
if ((renderParam.MapStaggerIndex.Equals(StaggerIndex.Odd) && tileY % 2 < 1) ||
(renderParam.MapStaggerIndex.Equals(StaggerIndex.Even) && tileY % 2 > 0))
{
// Even row in Odd Staggered Maps
// Odd row in Even Staggered Maps
pos.x = tileX * (renderParam.TileWidth / (float)tileSet.TileWidth);
pos.y = (-tileY - 1) * (tileDisplacement / (float)tileSet.TileHeight) - halfGap / (float)tileSet.TileHeight;
}
else
{
// Odd row in Odd Staggered Maps
// Even row in Even Staggered Maps
pos.x = tileX * (renderParam.TileWidth / (float)tileSet.TileWidth) + (renderParam.TileWidth / (float)tileSet.TileWidth) / 2.0f;
pos.y = (-tileY - 1) * (tileDisplacement / (float)tileSet.TileHeight) - halfGap / (float)tileSet.TileHeight;
}
}
else
{
float halfGap = (renderParam.TileWidth - renderParam.HexSideLength) / 2.0f;
float tileDisplacement = halfGap + renderParam.HexSideLength;
if ((renderParam.MapStaggerIndex.Equals(StaggerIndex.Odd) && tileX % 2 < 1) ||
(renderParam.MapStaggerIndex.Equals(StaggerIndex.Even) && tileX % 2 > 0))
{
// Even row in Odd Staggered Maps
// Odd row in Even Staggered Maps
pos.x = tileX * (tileDisplacement / (float)tileSet.TileWidth);
pos.y = (-tileY - 1) * (renderParam.TileHeight / (float)tileSet.TileHeight) * ((float)tileSet.TileHeight / (float)tileSet.TileWidth);
}
else
{
// Odd row in Odd Staggered Maps
// Even row in Even Staggered Maps
pos.x = tileX * (tileDisplacement / (float)tileSet.TileWidth);
pos.y = (-tileY - 1) * (renderParam.TileHeight / (float)tileSet.TileHeight) * ((float)tileSet.TileHeight / (float)tileSet.TileWidth) - (BaseMap.MapRenderParameter.TileHeight / (float)tileSet.TileHeight) / 2.0f * ((float)tileSet.TileHeight / (float)tileSet.TileWidth);
}
}
}
// Add TileSet Tile Offset
pos.x += tileSet.TileOffsetX / (float)renderParam.TileWidth;
pos.y += tileSet.TileOffsetY / (float)renderParam.TileHeight;
return pos;
}
void OnFinishedLoadingTileSet(TileSet tileSet)
{
TileSets.Add(tileSet);
_tileSetsToLoaded++;
if (_tileSetsToLoaded >= _numberOfTileSetsToLoad)
ContinueLoadingTiledMapAfterTileSetsLoaded();
}
private void onFinishedGeneratingTileSet(TileSet tileSet)
{
foreach (KeyValuePair<int, Tile> item in tileSet.Tiles)
{
this.Tiles.Add(item.Key, item.Value);
}
_tileSetsToLoaded++;
if (_tileSetsToLoaded >= _numberOfTileSetsToLoad)
GenerateTileSetsMaterials();
}
void Initialize(XmlDocument document, bool makeUnique, string fullPath, string mapPath)
{
XmlNode mapNode = document["map"];
Version = mapNode.Attributes["version"].Value;
Orientation = (Orientation)Enum.Parse(typeof(Orientation), mapNode.Attributes["orientation"].Value, true);
Width = int.Parse(mapNode.Attributes["width"].Value, CultureInfo.InvariantCulture);
Height = int.Parse(mapNode.Attributes["height"].Value, CultureInfo.InvariantCulture);
TileWidth = int.Parse(mapNode.Attributes["tilewidth"].Value, CultureInfo.InvariantCulture);
TileHeight = int.Parse(mapNode.Attributes["tileheight"].Value, CultureInfo.InvariantCulture);
XmlNode propertiesNode = document.SelectSingleNode("map/properties");
if (propertiesNode != null)
{
Properties = new PropertyCollection(propertiesNode); //Property.ReadProperties(propertiesNode);
}
TileSets = new List <TileSet>();
Tiles = new Dictionary <int, Tile>();
foreach (XmlNode tileSet in document.SelectNodes("map/tileset"))
{
if (tileSet.Attributes["source"] != null)
{
//TileSets.Add(new ExternalTileSetContent(tileSet, context));
XmlDocument externalTileSet = new XmlDocument();
TextAsset externalTileSetTextAsset = (TextAsset)Resources.Load(mapPath + Path.GetFileNameWithoutExtension(tileSet.Attributes["source"].Value));
//externalTileSet.Load(fullPath + "/" + tileSet.Attributes["source"].Value);
externalTileSet.LoadXml(externalTileSetTextAsset.text);
XmlNode externalTileSetNode = externalTileSet["tileset"];
//Debug.Log(externalTileSet.Value);
TileSet t = new TileSet(externalTileSetNode, mapPath);
TileSets.Add(t);
foreach (KeyValuePair <int, Tile> item in t.Tiles)
{
this.Tiles.Add(item.Key, item.Value);
}
//this.Tiles.AddRange(t.Tiles);
}
else
{
TileSet t = new TileSet(tileSet, mapPath);
TileSets.Add(t);
foreach (KeyValuePair <int, Tile> item in t.Tiles)
{
this.Tiles.Add(item.Key, item.Value);
}
}
}
// Generate Materials for Map batching
List <Material> materials = new List <Material>();
// Generate Materials
int i = 0;
for (i = 0; i < TileSets.Count; i++)
{
Material layerMat = new Material(Shader.Find("Unlit/Transparent"));
layerMat.mainTexture = TileSets[i].Texture;
materials.Add(layerMat);
}
Layers = new List <Layer>();
i = 0;
foreach (XmlNode layerNode in document.SelectNodes("map/layer|map/objectgroup"))
{
Layer layerContent;
float layerDepth = 1f - (LayerDepthSpacing * i);
if (layerNode.Name == "layer")
{
layerContent = new TileLayer(layerNode, this, layerDepth, makeUnique, materials);
//((TileLayer)layerContent).GenerateLayerMesh(MeshRendererPrefab);
}
else if (layerNode.Name == "objectgroup")
{
layerContent = new MapObjectLayer(layerNode, TileWidth, TileHeight);
}
else
{
throw new Exception("Unknown layer name: " + layerNode.Name);
}
// Layer names need to be unique for our lookup system, but Tiled
// doesn't require unique names.
string layerName = layerContent.Name;
int duplicateCount = 2;
// if a layer already has the same name...
if (Layers.Find(l => l.Name == layerName) != null)
{
// figure out a layer name that does work
do
{
layerName = string.Format("{0}{1}", layerContent.Name, duplicateCount);
duplicateCount++;
} while (Layers.Find(l => l.Name == layerName) != null);
// log a warning for the user to see
Debug.Log("Renaming layer \"" + layerContent.Name + "\" to \"" + layerName + "\" to make a unique name.");
// save that name
layerContent.Name = layerName;
}
layerContent.LayerDepth = layerDepth;
Layers.Add(layerContent);
namedLayers.Add(layerName, layerContent);
i++;
}
}
/// <summary>
/// Creates a new Tile object.
/// </summary>
/// <param name="texture">The texture that contains the tile image.</param>
/// <param name="source">The source rectangle of the tile.</param>
public Tile(TileSet tileSet, Rect source, int GID)
: this(tileSet, source, GID, new PropertyCollection())
{
}
void Initialize(XmlDocument document, bool makeUnique, string fullPath, string mapPath)
{
XmlNode mapNode = document["map"];
Version = mapNode.Attributes["version"].Value;
Orientation = (Orientation)Enum.Parse(typeof(Orientation), mapNode.Attributes["orientation"].Value, true);
Width = int.Parse(mapNode.Attributes["width"].Value, CultureInfo.InvariantCulture);
Height = int.Parse(mapNode.Attributes["height"].Value, CultureInfo.InvariantCulture);
TileWidth = int.Parse(mapNode.Attributes["tilewidth"].Value, CultureInfo.InvariantCulture);
TileHeight = int.Parse(mapNode.Attributes["tileheight"].Value, CultureInfo.InvariantCulture);
XmlNode propertiesNode = document.SelectSingleNode("map/properties");
if (propertiesNode != null)
{
Properties = new PropertyCollection(propertiesNode);//Property.ReadProperties(propertiesNode);
}
TileSets = new List<TileSet>();
Tiles = new Dictionary<int, Tile>();
foreach (XmlNode tileSet in document.SelectNodes("map/tileset"))
{
if (tileSet.Attributes["source"] != null)
{
//TileSets.Add(new ExternalTileSetContent(tileSet, context));
XmlDocument externalTileSet = new XmlDocument();
TextAsset externalTileSetTextAsset = (TextAsset)Resources.Load(mapPath + Path.GetFileNameWithoutExtension(tileSet.Attributes["source"].Value));
//externalTileSet.Load(fullPath + "/" + tileSet.Attributes["source"].Value);
externalTileSet.LoadXml(externalTileSetTextAsset.text);
XmlNode externalTileSetNode = externalTileSet["tileset"];
//Debug.Log(externalTileSet.Value);
TileSet t = new TileSet(externalTileSetNode, mapPath);
TileSets.Add(t);
foreach (KeyValuePair<int, Tile> item in t.Tiles)
{
this.Tiles.Add(item.Key, item.Value);
}
//this.Tiles.AddRange(t.Tiles);
}
else
{
TileSet t = new TileSet(tileSet, mapPath);
TileSets.Add(t);
foreach (KeyValuePair<int, Tile> item in t.Tiles)
{
this.Tiles.Add(item.Key, item.Value);
}
}
}
// Generate Materials for Map batching
List<Material> materials = new List<Material>();
// Generate Materials
int i = 0;
for (i = 0; i < TileSets.Count; i++)
{
Material layerMat = new Material(Shader.Find("Unlit/Transparent"));
layerMat.mainTexture = TileSets[i].Texture;
materials.Add(layerMat);
}
Layers = new List<Layer>();
i = 0;
foreach (XmlNode layerNode in document.SelectNodes("map/layer|map/objectgroup"))
{
Layer layerContent;
float layerDepth = 1f - (LayerDepthSpacing * i);
if (layerNode.Name == "layer")
{
layerContent = new TileLayer(layerNode, this, layerDepth, makeUnique, materials);
//((TileLayer)layerContent).GenerateLayerMesh(MeshRendererPrefab);
}
else if (layerNode.Name == "objectgroup")
{
layerContent = new MapObjectLayer(layerNode, TileWidth, TileHeight);
}
else
{
throw new Exception("Unknown layer name: " + layerNode.Name);
}
// Layer names need to be unique for our lookup system, but Tiled
// doesn't require unique names.
string layerName = layerContent.Name;
int duplicateCount = 2;
// if a layer already has the same name...
if (Layers.Find(l => l.Name == layerName) != null)
{
// figure out a layer name that does work
do
{
layerName = string.Format("{0}{1}", layerContent.Name, duplicateCount);
duplicateCount++;
} while (Layers.Find(l => l.Name == layerName) != null);
// log a warning for the user to see
Debug.Log("Renaming layer \"" + layerContent.Name + "\" to \"" + layerName + "\" to make a unique name.");
// save that name
layerContent.Name = layerName;
}
layerContent.LayerDepth = layerDepth;
Layers.Add(layerContent);
namedLayers.Add(layerName, layerContent);
i++;
}
}
/// <summary>
/// Sets a Tile in position x and y to be Tile with ID equals newTileID (a Local Tile ID from tileSet)
/// This does not works if the layer is not made of Unique Tiles.
/// </summary>
/// <param name="x">Tile X index</param>
/// <param name="y">Tile Y index</param>
/// <param name="newTileID">Local Tile ID to change existing tile to. If -1 is passed, erase current Tile</param>
/// <param name="tileSet">TileSet to read newTileID from</param>
/// <returns>true if newTileID inside tileSet was found and change succeded, false otherwise</returns>
public bool SetTile(int x, int y, int newTileID, TileSet tileSet)
{
if (x < 0 || x >= Width || y < 0 || y >= Height || !MakeUniqueTiles)
return false;
if (newTileID < 0)
{
if (Tiles[x, y] != null)
GameObject.Destroy(Tiles[x, y].TileGameObject);
Tiles[x, y] = null;
return true;
}
Tile t = null;
if (tileSet.Tiles.TryGetValue(newTileID, out t))
{
if (Tiles[x, y] != null)
{
Tiles[x, y].TileSprite = t.TileSprite;
Tiles[x, y].CurrentID = t.OriginalID;
(Tiles[x, y].TileGameObject.GetComponent<Renderer>() as SpriteRenderer).sprite = t.TileSprite;
}
else
{
Tile newTile = t.Clone();
CreateTileGameObject(newTile, x, y);
Tiles[x, y] = newTile;
}
return true;
}
return false;
}
private void Initialize(XDocument document, bool makeUnique, string fullPath, string mapPath, Material baseTileMaterial, int sortingOrder)
{
XElement mapNode = document.Root;
Version = mapNode.Attribute("version").Value;
Orientation = (Orientation)Enum.Parse(typeof(Orientation), mapNode.Attribute("orientation").Value, true);
Width = int.Parse(mapNode.Attribute("width").Value, CultureInfo.InvariantCulture);
Height = int.Parse(mapNode.Attribute("height").Value, CultureInfo.InvariantCulture);
TileWidth = int.Parse(mapNode.Attribute("tilewidth").Value, CultureInfo.InvariantCulture);
TileHeight = int.Parse(mapNode.Attribute("tileheight").Value, CultureInfo.InvariantCulture);
if (_mapName == null)
_mapName = "Map";
if (!mapPath.EndsWith("/"))
mapPath = mapPath + "/";
MapObject = new GameObject(_mapName);
MapObject.transform.parent = Parent.transform;
MapObject.transform.localPosition = Vector3.zero;
DefaultSortingOrder = sortingOrder;
XElement propertiesElement = mapNode.Element("properties");
if (propertiesElement != null)
Properties = new PropertyCollection(propertiesElement);
TileSets = new List<TileSet>();
Tiles = new Dictionary<int, Tile>();
foreach (XElement tileSet in mapNode.Descendants("tileset"))
{
if (tileSet.Attribute("source") != null)
{
TextAsset externalTileSetTextAsset = (TextAsset)Resources.Load(mapPath + Path.GetFileNameWithoutExtension(tileSet.Attribute("source").Value));
XDocument externalTileSet = XDocument.Parse(externalTileSetTextAsset.text);
XElement externalTileSetNode = externalTileSet.Element("tileset");
TileSet t = new TileSet(externalTileSetNode, mapPath);
TileSets.Add(t);
foreach (KeyValuePair<int, Tile> item in t.Tiles)
{
this.Tiles.Add(item.Key, item.Value);
}
}
else
{
TileSet t = new TileSet(tileSet, mapPath);
TileSets.Add(t);
foreach (KeyValuePair<int, Tile> item in t.Tiles)
{
this.Tiles.Add(item.Key, item.Value);
}
}
}
// Generate Materials for Map batching
List<Material> materials = new List<Material>();
// Generate Materials
int i = 0;
for (i = 0; i < TileSets.Count; i++)
{
Material layerMat = new Material(baseTileMaterial);
layerMat.mainTexture = TileSets[i].Texture;
materials.Add(layerMat);
}
Layers = new List<Layer>();
i = 0;
foreach (XElement layerNode in
mapNode.Elements("layer").Concat(
mapNode.Elements("objectgroup").Concat(
mapNode.Elements("imagelayer")))
)
{
Layer layerContent;
int layerDepth = 1 - (LayerDepthSpacing * i);
if (layerNode.Name == "layer")
{
layerContent = new TileLayer(layerNode, this, layerDepth, makeUnique, materials);
}
else if (layerNode.Name == "objectgroup")
{
layerContent = new MapObjectLayer(layerNode, this, layerDepth, materials);
}
else if (layerNode.Name == "imagelayer")
{
layerContent = new ImageLayer(layerNode, this, mapPath, baseTileMaterial);
}
else
{
throw new Exception("Unknown layer name: " + layerNode.Name);
}
// Layer names need to be unique for our lookup system, but Tiled
// doesn't require unique names.
string layerName = layerContent.Name;
int duplicateCount = 2;
// if a layer already has the same name...
if (Layers.Find(l => l.Name == layerName) != null)
{
// figure out a layer name that does work
do
{
layerName = string.Format("{0}{1}", layerContent.Name, duplicateCount);
duplicateCount++;
} while (Layers.Find(l => l.Name == layerName) != null);
// log a warning for the user to see
Debug.Log("Renaming layer \"" + layerContent.Name + "\" to \"" + layerName + "\" to make a unique name.");
// save that name
layerContent.Name = layerName;
}
layerContent.LayerDepth = layerDepth;
Layers.Add(layerContent);
namedLayers.Add(layerName, layerContent);
i++;
}
}
/// <summary>
/// Sets a Tile in position x and y to be Tile with ID equals newTileID (a Local Tile ID from tileSet)
/// This does not works if the layer is not made of Unique Tiles.
/// </summary>
/// <param name="x">Tile X index</param>
/// <param name="y">Tile Y index</param>
/// <param name="newTileID">Local Tile ID to change existing tile to. If -1 is passed, erase current Tile</param>
/// <param name="tileSet">TileSet to read newTileID from</param>
/// <returns>true if newTileID inside tileSet was found and change succeded, false otherwise</returns>
public bool SetTile(float x, float y, int newTileID, TileSet tileSet)
{
return(SetTile(Mathf.FloorToInt(x), Mathf.FloorToInt(y), newTileID, tileSet));
}
