public Tiled.Layer Map(LayerTilemap src, Tiled.Layer dst = null)
{
if (dst == null)
{
dst = new Tiled.Layer();
}
dst.Name = src.Name;
dst.Visible = src.Visible;
dst.Properties[nameof(LayerTilemap.DefinitionId)] = src.DefinitionId;
dst.Opacity = src.Opacity;
dst.Properties[nameof(LayerTilemap.ProcessingMode)] = src.ProcessingMode;
dst.Width = src.Width;
dst.Height = src.Height;
dst.Data = new uint[src.Width, src.Height];
for (int y = 0; y < src.Height; y++)
{
for (int x = 0; x < src.Width; x++)
{
var data = src.Tiles[x, y];
dst.Data[x, y] = (uint)(
(data.Index & Tiled.Layer.INDEX_FLAG) |
(data.IsFlippedX ? Tiled.Layer.FLIPPED_HORIZONTALLY_FLAG : 0) |
(data.IsFlippedY ? Tiled.Layer.FLIPPED_VERTICALLY_FLAG : 0)
);
}
}
dst.Encoding = "base64";
dst.Compression = "gzip";
return(dst);
}
public LayerTilemap Map(Tiled.Layer src, LayerTilemap dst = null)
{
if (dst == null)
{
dst = new LayerTilemap();
}
dst.Name = src.Name;
dst.Visible = src.Visible;
dst.Opacity = src.Opacity;
dst.DefinitionId = GetPropertyValue(src.Properties, default(Guid), nameof(LayerTilemap.DefinitionId));
dst.ProcessingMode = GetPropertyValue(src.Properties, LayerProcessingMode.Tilemap,
nameof(LayerTilemap.ProcessingMode));
dst.Tiles = new Tile[src.Data.GetLength(0), src.Data.GetLength(1)];
for (int y = 0; y < src.Height; y++)
{
for (int x = 0; x < src.Width; x++)
{
var data = src.Data[x, y];
dst.Tiles[x, y] = new Tile()
{
Tileset = 0,
Index = (int)(data & Tiled.Layer.INDEX_FLAG),
IsFlippedX = (data & Tiled.Layer.FLIPPED_HORIZONTALLY_FLAG) != 0,
IsFlippedY = (data & Tiled.Layer.FLIPPED_VERTICALLY_FLAG) != 0
};
}
}
return(dst);
}
//Load tilemap data from a stream (in a tiled JSON format)
//return false on failure, or just throws an exception
public bool load(StreamReader stream)
{
landMarks.Clear();
JsonSerializer js = new JsonSerializer();
Tiled.TileMap map = js.Deserialize <Tiled.TileMap>(new JsonTextReader(stream));
if (map.height == 0 || map.width == 0)
{
return(false);
}
tileDefinitions = new Dictionary <long, TileDefinition>();
foreach (var k in map.tilesets)
{
foreach (var pair in k.tiles)
{
var gid = pair.Key + k.firstgid;
TileDefinition tiledef = new TileDefinition();
tiledef.image = pair.Value.image;
tileDefinitions.Add(gid, tiledef);
}
}
Tiled.Layer tilelayer = null;
Tiled.Layer colllayer = null;
foreach (var lay in map.layers)
{
if (lay.type == "tilelayer")
{
if (lay.name == "terrain")
{
tilelayer = lay;
}
if (lay.name == "collision")
{
colllayer = lay;
}
}
if (lay.type == "objectgroup" && lay.objects != null)
{
if (lay.name == "landmarks")
{
foreach (var obj in lay.objects)
{
LandMark l = new LandMark();
//Tiled object position refers to the lower left point of the object
//(lowest x value, highest y value)
if (obj.properties != null)
{
l.properties = new Dictionary <string, string>(obj.properties);
}
else
{
l.properties = new Dictionary <string, string>();
}
l.image = "";
TileDefinition td;
tileDefinitions.TryGetValue(obj.gid & gidmask, out td);
if (obj.gid > 0)
{
l.image = td.image;
l.area = new Rectangle(new Vec2(obj.x + obj.width / 2, obj.y - obj.height / 2), obj.width, obj.height);
}
else
{
l.area = new Rectangle(new Vec2(obj.x + obj.width / 2, obj.y + obj.height / 2), obj.width, obj.height);
}
landMarks.Add(l);
}
}
}
}
if (tilelayer == null)
{
return(false);
}
if (tilelayer.data.Count != map.width * map.height)
{
return(false);
}
if (colllayer == null || colllayer.data.Count != map.width * map.height)
{
colllayer = null;
}
_height = map.height;
_width = map.width;
tiles = new List <Tile>();
int i = 0;
foreach (var k in tilelayer.data)
{
bool collision = false;
if (colllayer != null)
{
collision = colllayer.data[i] > 0;
}
TileDefinition td = null;
tileDefinitions.TryGetValue(k, out td);
Tile t = new Tile(td, collision);
tiles.Add(t);
i++;
}
return(true);
}
