public static TmxGroupLayer FromXml(XElement xml, TmxLayerNode parent, TmxMap tmxMap)
{
TmxGroupLayer tmxGroupLayer = new TmxGroupLayer(parent, tmxMap);
tmxGroupLayer.FromXmlInternal(xml);
return(tmxGroupLayer);
}
private void ParseMapXml(XDocument doc)
{
Logger.WriteVerbose("Parsing map root ...");
XElement xElement = doc.Element("map");
try
{
Orientation = TmxHelper.GetAttributeAsEnum <MapOrientation>(xElement, "orientation");
StaggerAxis = TmxHelper.GetAttributeAsEnum(xElement, "staggeraxis", MapStaggerAxis.Y);
StaggerIndex = TmxHelper.GetAttributeAsEnum(xElement, "staggerindex", MapStaggerIndex.Odd);
HexSideLength = TmxHelper.GetAttributeAsInt(xElement, "hexsidelength", 0);
DrawOrderHorizontal = (TmxHelper.GetAttributeAsString(xElement, "renderorder", "right-down").Contains("right") ? 1 : (-1));
DrawOrderVertical = (TmxHelper.GetAttributeAsString(xElement, "renderorder", "right-down").Contains("down") ? 1 : (-1));
Width = TmxHelper.GetAttributeAsInt(xElement, "width");
Height = TmxHelper.GetAttributeAsInt(xElement, "height");
TileWidth = TmxHelper.GetAttributeAsInt(xElement, "tilewidth");
TileHeight = TmxHelper.GetAttributeAsInt(xElement, "tileheight");
BackgroundColor = TmxHelper.GetAttributeAsColor(xElement, "backgroundcolor", new Color32(128, 128, 128, 255));
}
catch (Exception inner)
{
TmxException.FromAttributeException(inner, xElement);
}
Properties = TmxProperties.FromXml(xElement);
IsResource = Properties.GetPropertyValueAsBoolean("unity:resource", false);
IsResource = (IsResource || !string.IsNullOrEmpty(Properties.GetPropertyValueAsString("unity:resourcePath", null)));
ExplicitSortingLayerName = Properties.GetPropertyValueAsString("unity:sortingLayerName", "");
ParseAllTilesets(doc);
ParseAllTemplates(doc);
LayerNodes = TmxLayerNode.ListFromXml(xElement, null, this);
MapSizeInPixels = CalculateMapSizeInPixels();
TmxDisplayOrderVisitor visitor = new TmxDisplayOrderVisitor();
Visit(visitor);
}
public static List <TmxLayerNode> ListFromXml(XElement xmlRoot, TmxLayerNode parent, TmxMap tmxMap)
{
List <TmxLayerNode> nodes = new List <TmxLayerNode>();
foreach (var xmlNode in xmlRoot.Elements())
{
TmxLayerNode layerNode = null;
if (xmlNode.Name == "layer" || xmlNode.Name == "imagelayer")
{
layerNode = TmxLayer.FromXml(xmlNode, parent, tmxMap);
}
else if (xmlNode.Name == "objectgroup")
{
layerNode = TmxObjectGroup.FromXml(xmlNode, parent, tmxMap);
}
else if (xmlNode.Name == "group")
{
layerNode = TmxGroupLayer.FromXml(xmlNode, parent, tmxMap);
}
// If the layer is visible then add it to our list
if (layerNode != null && layerNode.Visible)
{
nodes.Add(layerNode);
}
}
return(nodes);
}
protected void FromXmlInternal(XElement xml)
{
// Get common elements amoung layer nodes from xml
this.Name = TmxHelper.GetAttributeAsString(xml, "name", "");
this.Visible = TmxHelper.GetAttributeAsInt(xml, "visible", 1) == 1;
this.Opacity = TmxHelper.GetAttributeAsFloat(xml, "opacity", 1);
// Get the offset
PointF offset = new PointF(0, 0);
offset.X = TmxHelper.GetAttributeAsFloat(xml, "offsetx", 0);
offset.Y = TmxHelper.GetAttributeAsFloat(xml, "offsety", 0);
this.Offset = offset;
// Get all the properties
this.Properties = TmxProperties.FromXml(xml);
// Set the "ignore" setting on this object group
this.Ignore = this.Properties.GetPropertyValueAsEnum <IgnoreSettings>("unity:ignore", IgnoreSettings.False);
// Explicit sorting properties
this.ExplicitSortingLayerName = this.Properties.GetPropertyValueAsString("unity:sortingLayerName", "");
if (this.Properties.PropertyMap.ContainsKey("unity:sortingOrder"))
{
this.ExplicitSortingOrder = this.Properties.GetPropertyValueAsInt("unity:sortingOrder");
}
// Are we using a unity:layer override?
this.UnityLayerOverrideName = this.Properties.GetPropertyValueAsString("unity:layer", "");
// Add all our children
this.LayerNodes = TmxLayerNode.ListFromXml(xml, this, this.TmxMap);
}
public static List <TmxLayerNode> ListFromXml(XElement xmlRoot, TmxLayerNode parent, TmxMap tmxMap)
{
List <TmxLayerNode> list = new List <TmxLayerNode>();
foreach (XElement item in xmlRoot.Elements())
{
TmxLayerNode tmxLayerNode = null;
if (item.Name == (XName)"layer" || item.Name == (XName)"imagelayer")
{
tmxLayerNode = TmxLayer.FromXml(item, parent, tmxMap);
}
else if (item.Name == (XName)"objectgroup")
{
tmxLayerNode = TmxObjectGroup.FromXml(item, parent, tmxMap);
}
else if (item.Name == (XName)"group")
{
tmxLayerNode = TmxGroupLayer.FromXml(item, parent, tmxMap);
}
if (tmxLayerNode != null && tmxLayerNode.Visible && tmxLayerNode.Ignore != IgnoreSettings.True)
{
list.Add(tmxLayerNode);
}
}
return(list);
}
public TmxLayer(TmxLayerNode parent, TmxMap map)
: base(parent, map)
{
base.Visible = true;
base.Opacity = 1f;
Data = new TmxData(this);
CollisionLayers = new List <TmxLayer>();
}
public TmxLayerNode(TmxLayerNode parent, TmxMap tmxMap)
{
this.DrawOrderIndex = -1;
this.DepthBufferIndex = -1;
this.ParentNode = parent;
this.TmxMap = tmxMap;
this.LayerNodes = new List <TmxLayerNode>();
}
public TmxLayerNode(TmxLayerNode parent, TmxMap tmxMap)
{
DrawOrderIndex = -1;
DepthBufferIndex = -1;
ParentNode = parent;
ParentMap = tmxMap;
LayerNodes = new List <TmxLayerNode>();
}
public static TmxGroupLayer FromXml(XElement xml, TmxLayerNode parent, TmxMap tmxMap)
{
Debug.Assert(xml.Name == "group");
TmxGroupLayer tmxGroupLayer = new TmxGroupLayer(parent, tmxMap);
tmxGroupLayer.FromXmlInternal(xml);
return(tmxGroupLayer);
}
public PointF GetCombinedOffset()
{
PointF pointF = Offset;
for (TmxLayerNode parentNode = ParentNode; parentNode != null; parentNode = parentNode.ParentNode)
{
pointF = TmxMath.AddPoints(pointF, parentNode.Offset);
}
return(pointF);
}
public PointF GetCombinedOffset()
{
PointF offset = this.Offset;
TmxLayerNode parent = this.ParentNode;
while (parent != null)
{
offset = TmxMath.AddPoints(offset, parent.Offset);
parent = parent.ParentNode;
}
return(offset);
}
public static TmxObjectGroup FromXml(XElement xml, TmxLayerNode parent, TmxMap tmxMap)
{
TmxObjectGroup tmxObjectGroup = new TmxObjectGroup(parent, tmxMap);
tmxObjectGroup.FromXmlInternal(xml);
tmxObjectGroup.Color = TmxHelper.GetAttributeAsColor(xml, "color", new Color32(128, 128, 128, 255));
Logger.WriteVerbose("Parsing objects in object group '{0}'", tmxObjectGroup.Name);
IEnumerable <TmxObject> source = from obj in xml.Elements("object")
select TmxObject.FromXml(obj, tmxObjectGroup, tmxMap);
tmxObjectGroup.Objects = (from o in source
orderby TmxMath.ObjectPointFToMapSpace(tmxMap, o.Position).Y
select o).ToList();
return(tmxObjectGroup);
}
public static float CalculateLayerDepth(TmxLayerNode layer)
{
if (!Tiled2Unity.Settings.DepthBufferEnabled)
{
return(0.0f);
}
float depthOfOneTile = layer.TmxMap.TileHeight / (float)layer.TmxMap.MapSizeInPixels.Height;
float z = layer.DepthBufferIndex * depthOfOneTile * -1.0f;
// How much is our layer offset as a function of tiles?
float offsetRatio = layer.Offset.Y / layer.TmxMap.TileHeight;
z -= offsetRatio * depthOfOneTile;
return((z == -0.0f) ? 0 : z);
}
private IEnumerable <T> RecursiveEnumerate <T>(TmxLayerNode layerNode) where T : TmxLayerNode
{
// Is this node the type we're looking for?
if (layerNode.GetType() == typeof(T))
{
yield return((T)layerNode);
}
// Go through all children nodes
foreach (var child in layerNode.LayerNodes)
{
foreach (var recursive in RecursiveEnumerate <T>(child))
{
yield return(recursive);
}
}
}
public static TmxLayer FromXml(XElement elem, TmxLayerNode parent, TmxMap tmxMap)
{
TmxLayer tmxLayer = new TmxLayer(parent, tmxMap);
tmxLayer.FromXmlInternal(elem);
if (elem.Name == (XName)"layer")
{
tmxLayer.ParseLayerXml(elem);
}
else if (elem.Name == (XName)"imagelayer")
{
tmxLayer.ParseImageLayerXml(elem);
}
tmxLayer.Meshes = TmxMesh.ListFromTmxLayer(tmxLayer);
tmxLayer.BuildCollisionLayers();
return(tmxLayer);
}
private void ParseMapXml(XDocument doc)
{
Logger.WriteVerbose("Parsing map root ...");
XElement map = doc.Element("map");
try
{
this.Orientation = TmxHelper.GetAttributeAsEnum <MapOrientation>(map, "orientation");
this.StaggerAxis = TmxHelper.GetAttributeAsEnum(map, "staggeraxis", MapStaggerAxis.Y);
this.StaggerIndex = TmxHelper.GetAttributeAsEnum(map, "staggerindex", MapStaggerIndex.Odd);
this.HexSideLength = TmxHelper.GetAttributeAsInt(map, "hexsidelength", 0);
this.DrawOrderHorizontal = TmxHelper.GetAttributeAsString(map, "renderorder", "right-down").Contains("right") ? 1 : -1;
this.DrawOrderVertical = TmxHelper.GetAttributeAsString(map, "renderorder", "right-down").Contains("down") ? 1 : -1;
this.Width = TmxHelper.GetAttributeAsInt(map, "width");
this.Height = TmxHelper.GetAttributeAsInt(map, "height");
this.TileWidth = TmxHelper.GetAttributeAsInt(map, "tilewidth");
this.TileHeight = TmxHelper.GetAttributeAsInt(map, "tileheight");
this.BackgroundColor = TmxHelper.GetAttributeAsColor(map, "backgroundcolor", Color.FromArgb(128, 128, 128));
}
catch (Exception e)
{
TmxException.FromAttributeException(e, map);
}
// Collect our map properties
this.Properties = TmxProperties.FromXml(map);
// Check properties for us being a resource
this.IsResource = this.Properties.GetPropertyValueAsBoolean("unity:resource", false);
this.IsResource = this.IsResource || !String.IsNullOrEmpty(this.Properties.GetPropertyValueAsString("unity:resourcePath", null));
ParseAllTilesets(doc);
// Get all our child layer nodes
this.LayerNodes = TmxLayerNode.ListFromXml(map, null, this);
// Calcuate the size of the map. Isometric and hex maps make this more complicated than a simple width and height thing.
this.MapSizeInPixels = CalculateMapSizeInPixels();
// Visit each node in the map to assign display order
TmxDisplayOrderVisitor visitor = new TmxDisplayOrderVisitor();
this.Visit(visitor);
}
private IEnumerable <T> EnumerateLayersByType <T>() where T : TmxLayerNode
{
List <TmxLayerNode> .Enumerator enumerator = LayerNodes.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
TmxLayerNode current = enumerator.Current;
foreach (T item in RecursiveEnumerate <T>(current))
{
yield return(item);
}
}
}
finally
{
((IDisposable)enumerator).Dispose();
}
enumerator = default(List <TmxLayerNode> .Enumerator);
}
public static TmxObjectGroup FromXml(XElement xml, TmxLayerNode parent, TmxMap tmxMap)
{
Debug.Assert(xml.Name == "objectgroup");
TmxObjectGroup tmxObjectGroup = new TmxObjectGroup(parent, tmxMap);
tmxObjectGroup.FromXmlInternal(xml);
// Color is specific to object group
tmxObjectGroup.Color = TmxHelper.GetAttributeAsColor(xml, "color", Color.FromArgb(128, 128, 128));
// Get all the objects
Logger.WriteVerbose("Parsing objects in object group '{0}'", tmxObjectGroup.Name);
var objects = from obj in xml.Elements("object")
select TmxObject.FromXml(obj, tmxObjectGroup, tmxMap);
// The objects are ordered "visually" by Y position
tmxObjectGroup.Objects = objects.ToList();
return(tmxObjectGroup);
}
private void AddLayerNodeToElement(TmxLayerNode node, XElement xml)
{
// Bail if the node is invisible
if (node.Visible == false)
{
return;
}
// What type of node are we dealing with?
if (node is TmxGroupLayer)
{
AddGroupLayerToElement(node as TmxGroupLayer, xml);
}
else if (node is TmxLayer)
{
AddTileLayerToElement(node as TmxLayer, xml);
}
else if (node is TmxObjectGroup)
{
AddObjectLayerToElement(node as TmxObjectGroup, xml);
}
}
private void AddLayerNodeToElement(TmxLayerNode node, XElement xml)
{
// Bail if the node is invisible
if (node.Visible == false)
{
return;
}
xml.SetAttributeValue("sortingOrder", node.GetSortingOrder());
// What type of node are we dealing with?
if (node is TmxGroupLayer)
{
AddGroupLayerToElement(node as TmxGroupLayer, xml);
}
else if (node is TmxLayer)
{
AddTileLayerToElement(node as TmxLayer, xml);
}
else if (node is TmxObjectGroup)
{
AddObjectLayerToElement(node as TmxObjectGroup, xml);
}
}
private IEnumerable <T> RecursiveEnumerate <T>(TmxLayerNode layerNode) where T : TmxLayerNode
{
if (layerNode.GetType() == typeof(T))
{
yield return((T)layerNode);
}
List <TmxLayerNode> .Enumerator enumerator = layerNode.LayerNodes.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
TmxLayerNode current = enumerator.Current;
foreach (T item in RecursiveEnumerate <T>(current))
{
yield return(item);
}
}
}
finally
{
((IDisposable)enumerator).Dispose();
}
enumerator = default(List <TmxLayerNode> .Enumerator);
}
public static TmxLayer FromXml(XElement elem, TmxLayerNode parent, TmxMap tmxMap)
{
TmxLayer tmxLayer = new TmxLayer(parent, tmxMap);
tmxLayer.FromXmlInternal(elem);
// We can build a layer from a "tile layer" (default) or an "image layer"
if (elem.Name == "layer")
{
tmxLayer.Width = TmxHelper.GetAttributeAsInt(elem, "width");
tmxLayer.Height = TmxHelper.GetAttributeAsInt(elem, "height");
tmxLayer.ParseData(elem.Element("data"));
}
else if (elem.Name == "imagelayer")
{
XElement xmlImage = elem.Element("image");
if (xmlImage == null)
{
Logger.WriteWarning("Image Layer '{0}' is being ignored since it has no image.", tmxLayer.Name);
tmxLayer.Ignore = IgnoreSettings.True;
return(tmxLayer);
}
// An image layer is sort of like an tile layer but with just one tile
tmxLayer.Width = 1;
tmxLayer.Height = 1;
// Find the "tile" that matches our image
string imagePath = TmxHelper.GetAttributeAsFullPath(elem.Element("image"), "source");
TmxTile tile = tmxMap.Tiles.First(t => t.Value.TmxImage.AbsolutePath == imagePath).Value;
tmxLayer.TileIds = new uint[1] {
tile.GlobalId
};
// The image layer needs to be tranlated in an interesting way when expressed as a tile layer
PointF translated = tmxLayer.Offset;
// Make up for height of a regular tile in the map
translated.Y -= (float)tmxMap.TileHeight;
// Make up for the height of this image
translated.Y += (float)tile.TmxImage.Size.Height;
// Correct for any orientation effects on the map (like isometric)
// (We essentially undo the translation via orientation here)
PointF orientation = TmxMath.TileCornerInScreenCoordinates(tmxMap, 0, 0);
translated.X -= orientation.X;
translated.Y -= orientation.Y;
// Translate by the x and y coordiantes
translated.X += TmxHelper.GetAttributeAsFloat(elem, "x", 0);
translated.Y += TmxHelper.GetAttributeAsFloat(elem, "y", 0);
tmxLayer.Offset = translated;
}
// Sometimes TMX files have "dead" tiles in them (tiles that were removed but are still referenced)
// Remove these tiles from the layer by replacing them with zero
for (int t = 0; t < tmxLayer.TileIds.Length; ++t)
{
uint tileId = tmxLayer.TileIds[t];
tileId = TmxMath.GetTileIdWithoutFlags(tileId);
if (!tmxMap.Tiles.ContainsKey(tileId))
{
tmxLayer.TileIds[t] = 0;
}
}
// Each layer will be broken down into "meshes" which are collections of tiles matching the same texture or animation
tmxLayer.Meshes = TmxMesh.ListFromTmxLayer(tmxLayer);
// Each layer may contain different collision types which are themselves put into "Collison Layers" to be processed later
tmxLayer.BuildCollisionLayers();
return(tmxLayer);
}
public TmxLayer(TmxLayerNode parent, TmxMap map) : base(parent, map)
{
this.Visible = true;
this.Opacity = 1.0f;
this.CollisionLayers = new List <TmxLayer>();
}
public TmxGroupLayer(TmxLayerNode parent, TmxMap tmxMap)
: base(parent, tmxMap)
{
}
public TmxObjectGroup(TmxLayerNode parent, TmxMap tmxMap)
: base(parent, tmxMap)
{
Objects = new List <TmxObject>();
}
