public void CreateTileArray(TmxLayer levelLayer)
{
Tile[,] tiles = new Tile[TileMap.RowCount, TileMap.ColumnCount];
for (var i = 0; i < levelLayer.Tiles.Count; i++)
{
//our value
int gid = levelLayer.Tiles[i].Gid;
if (gid != 0)
{
gid--;
SpriteHolder spriteHolder = SpritePositions[gid];
//we are a ground type else solid
if (gid == 434)
{
tiles[levelLayer.Tiles[i].X, levelLayer.Tiles[i].Y] = new Tile("", levelLayer.Tiles[i].X, levelLayer.Tiles[i].Y, TileMap.TileSize, TileMap.TileSize, new Rectangle(spriteHolder.origin.ToPoint().X, spriteHolder.origin.ToPoint().Y, TileMap.TileSize, TileMap.TileSize), TileType.Ground);
}
else
{
tiles[levelLayer.Tiles[i].X, levelLayer.Tiles[i].Y] = new Tile("", levelLayer.Tiles[i].X, levelLayer.Tiles[i].Y, TileMap.TileSize, TileMap.TileSize, new Rectangle(spriteHolder.origin.ToPoint().X, spriteHolder.origin.ToPoint().Y, TileMap.TileSize, TileMap.TileSize), TileType.Solid);
}
}
else
{
SpriteHolder spriteHolder = SpritePositions[301];
int size = random.Next(0, 5);
tiles[levelLayer.Tiles[i].X, levelLayer.Tiles[i].Y] = new Tile("", levelLayer.Tiles[i].X, levelLayer.Tiles[i].Y, TileMap.TileSize, TileMap.TileSize, new Rectangle(spriteHolder.origin.ToPoint().X, spriteHolder.origin.ToPoint().Y, size, size), TileType.Solid);
}
}
TileMap.Map = tiles;
TileMap.aStar = new AStarSolver<Tile, Object>(TileMap.Map);
}
public TmxGroup(XElement xGroup, int width, int height, string tmxDirectory)
{
Name = (string)xGroup.Attribute("name") ?? String.Empty;
Opacity = (double?)xGroup.Attribute("opacity") ?? 1.0;
Visible = (bool?)xGroup.Attribute("visible") ?? true;
OffsetX = (double?)xGroup.Attribute("offsetx") ?? 0.0;
OffsetY = (double?)xGroup.Attribute("offsety") ?? 0.0;
Properties = new PropertyDict(xGroup.Element("properties"));
Layers = new TmxList <ITmxLayer>();
TileLayers = new TmxList <TmxLayer>();
ObjectGroups = new TmxList <TmxObjectGroup>();
ImageLayers = new TmxList <TmxImageLayer>();
Groups = new TmxList <TmxGroup>();
foreach (var e in xGroup.Elements().Where(x => x.Name == "layer" || x.Name == "objectgroup" || x.Name == "imagelayer" || x.Name == "group"))
{
ITmxLayer layer;
switch (e.Name.LocalName)
{
case "layer":
var tileLayer = new TmxLayer(e, width, height);
layer = tileLayer;
TileLayers.Add(tileLayer);
break;
case "objectgroup":
var objectgroup = new TmxObjectGroup(e);
layer = objectgroup;
ObjectGroups.Add(objectgroup);
break;
case "imagelayer":
var imagelayer = new TmxImageLayer(e, tmxDirectory);
layer = imagelayer;
ImageLayers.Add(imagelayer);
break;
case "group":
var group = new TmxGroup(e, width, height, tmxDirectory);
layer = group;
Groups.Add(group);
break;
default:
throw new InvalidOperationException();
}
Layers.Add(layer);
}
}
private static Tile LoadTile(TmxLayer tmxLayer, TmxLayerTile tmxTile, Tileset[] tilesets, ContentManager content, GraphicsDevice graphicsDevice)
{
Tile tile = null;
if (tmxTile.Gid != 0)
{
// Try and find the tileset.
foreach (var tileset in tilesets)
{
if (tmxTile.Gid >= tileset.FirstGid && tmxTile.Gid <= tileset.LastGid)
{
int srcY = (((tmxTile.Gid - tileset.FirstGid) / tileset.TilesPerRow) * 32);
int srcX = (((tmxTile.Gid - tileset.FirstGid) % tileset.TilesPerRow) * 32);
tile = new Tile(tileset, new Rectangle(srcX, srcY, tileset.TileWidth, tileset.TileHeight), new Vector2(tmxTile.X * 32, tmxTile.Y * 32), tmxLayer.Opacity);
break;
}
}
}
return tile ?? new Tile(null, new Rectangle(), Vector2.Zero, tmxLayer.Opacity);
}
/// <summary>
/// Initializes a new instance of the <see cref="TiledMapLayer" /> class.
/// </summary>
/// <param name="tmxLayer">The tmx parsed layer.</param>
public TiledMapLayer(TmxLayer tmxLayer)
{
this.tmxLayer = tmxLayer;
this.tiles = new List<LayerTile>();
this.NeedRefresh = true;
}
private void Load(XDocument xDoc)
{
var xMap = xDoc.Element("map");
Version = (string)xMap.Attribute("version");
TiledVersion = (string)xMap.Attribute("tiledversion");
Width = (int)xMap.Attribute("width");
Height = (int)xMap.Attribute("height");
TileWidth = (int)xMap.Attribute("tilewidth");
TileHeight = (int)xMap.Attribute("tileheight");
HexSideLength = (int?)xMap.Attribute("hexsidelength");
// Map orientation type
var orientDict = new Dictionary <string, OrientationType> {
{ "unknown", OrientationType.Unknown },
{ "orthogonal", OrientationType.Orthogonal },
{ "isometric", OrientationType.Isometric },
{ "staggered", OrientationType.Staggered },
{ "hexagonal", OrientationType.Hexagonal },
};
var orientValue = (string)xMap.Attribute("orientation");
if (orientValue != null)
{
Orientation = orientDict[orientValue];
}
// Hexagonal stagger axis
var staggerAxisDict = new Dictionary <string, StaggerAxisType> {
{ "x", StaggerAxisType.X },
{ "y", StaggerAxisType.Y },
};
var staggerAxisValue = (string)xMap.Attribute("staggeraxis");
if (staggerAxisValue != null)
{
StaggerAxis = staggerAxisDict[staggerAxisValue];
}
// Hexagonal stagger index
var staggerIndexDict = new Dictionary <string, StaggerIndexType> {
{ "odd", StaggerIndexType.Odd },
{ "even", StaggerIndexType.Even },
};
var staggerIndexValue = (string)xMap.Attribute("staggerindex");
if (staggerIndexValue != null)
{
StaggerIndex = staggerIndexDict[staggerIndexValue];
}
// Tile render order
var renderDict = new Dictionary <string, RenderOrderType> {
{ "right-down", RenderOrderType.RightDown },
{ "right-up", RenderOrderType.RightUp },
{ "left-down", RenderOrderType.LeftDown },
{ "left-up", RenderOrderType.LeftUp }
};
var renderValue = (string)xMap.Attribute("renderorder");
if (renderValue != null)
{
RenderOrder = renderDict[renderValue];
}
NextObjectID = (int?)xMap.Attribute("nextobjectid");
BackgroundColor = new TmxColor(xMap.Attribute("backgroundcolor"));
Properties = new PropertyDict(xMap.Element("properties"));
Tilesets = new TmxList <TmxTileset>();
foreach (var e in xMap.Elements("tileset"))
{
Tilesets.Add(new TmxTileset(e, TmxDirectory, CustomLoader));
}
Layers = new TmxList <ITmxLayer>();
TileLayers = new TmxList <TmxLayer>();
ObjectGroups = new TmxList <TmxObjectGroup>();
ImageLayers = new TmxList <TmxImageLayer>();
Groups = new TmxList <TmxGroup>();
foreach (var e in xMap.Elements().Where(x => x.Name == "layer" || x.Name == "objectgroup" || x.Name == "imagelayer" || x.Name == "group"))
{
ITmxLayer layer;
switch (e.Name.LocalName)
{
case "layer":
var tileLayer = new TmxLayer(e, Width, Height);
layer = tileLayer;
TileLayers.Add(tileLayer);
break;
case "objectgroup":
var objectgroup = new TmxObjectGroup(e);
layer = objectgroup;
ObjectGroups.Add(objectgroup);
break;
case "imagelayer":
var imagelayer = new TmxImageLayer(e, TmxDirectory);
layer = imagelayer;
ImageLayers.Add(imagelayer);
break;
case "group":
var group = new TmxGroup(e, Width, Height, TmxDirectory);
layer = group;
Groups.Add(group);
break;
default:
throw new InvalidOperationException();
}
Layers.Add(layer);
}
}
private void generateTiles()
{
tiles = new Dictionary<Tuple<int, int>, Tile>();
// Create tile objects
bool passLayer = map.Layers.Contains("pass");
if (passLayer)
{
passabilityLayer = map.Layers["pass"];
Tile tile;
for (int index = 0; index < passabilityLayer.Tiles.Count; index++)
{
int x = index % width;
int y = index / width;
tile = new Tile(new Point(x, y), (passabilityLayer.Tiles[index].Gid == 0));
tiles[new Tuple<int, int>(x, y)] = tile;
}
foreach (Tuple<int, int> key in tiles.Keys)
{
generateNeighbours(key.Item1, key.Item2);
}
}
else
{
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++)
tiles[new Tuple<int, int>(x, y)] = new Tile(new Point(x, y), true);
}
}
private void DrawMapLayer(TmxLayer layer)
{
TmxMap map = currentMap.TmxMap;
int size = Global.TileSize;
for (var i = 0; i < layer.Tiles.Count; i++)
{
int gid = layer.Tiles[i].Gid;
if (gid != 0)
{
Tileset tileset = currentMap.GetTileset(gid);
int tileFrame = gid - tileset.FirstGid;
int column = tileFrame % tileset.TilesWide;
int row = tileFrame / tileset.TilesWide;
float x = (i % map.Width) * map.TileWidth;
float y = (float)Math.Floor(i / (double)map.Width) * map.TileHeight;
Rectangle tilesetRec = new Rectangle(size * column, size * row, size, size);
spriteBatch.Draw(tileset.Texture, new Rectangle((int)x, (int)y, size, size), tilesetRec, Color.White);
}
}
}
/// <summary>
/// Unload layer
/// </summary>
private void UnloadLayer()
{
this.tiledMap = null;
this.tileTable = null;
this.tiles = null;
this.tmxLayer = null;
this.isLayerLoaded = false;
}
/// <summary>
/// Initialize Layer
/// </summary>
private void LoadLayer()
{
this.tiles = new List<LayerTile>();
if(this.Owner.Parent == null)
{
return;
}
this.tiledMap = this.Owner.Parent.FindComponent<TiledMap>();
if (this.tiledMap != null && this.tiledMap.TmxMap != null)
{
this.tmxLayer = this.tiledMap.TmxMap.Layers.FirstOrDefault(l => l.Name == this.tmxLayerName);
if (this.tmxLayer != null)
{
this.tileTable = new LayerTile[this.tiledMap.Width, this.tiledMap.Height];
for (int i = 0; i < this.tmxLayer.Tiles.Count; i++)
{
var tmxTile = this.tmxLayer.Tiles[i];
Tileset selectedTileset = null;
if (tmxTile.Gid > 0)
{
foreach (var tileset in this.tiledMap.Tilesets)
{
if (tmxTile.Gid <= tileset.LastGid)
{
selectedTileset = tileset;
break;
}
}
}
LayerTile tile = new LayerTile(tmxTile, selectedTileset);
this.tiles.Add(tile);
Vector2 tileLocalPosition;
this.tiledMap.GetTilePosition(tile.X, tile.Y, selectedTileset, out tileLocalPosition);
tile.LocalPosition = tileLocalPosition;
int x = i % this.tiledMap.Width;
int y = i / this.tiledMap.Width;
this.tileTable[x, y] = tile;
}
this.isLayerLoaded = true;
this.NeedRefresh = true;
}
}
}
/// <summary>
/// Create the tile layer as a child entity
/// </summary>
/// <param name="tmxLayer">the tmx parsed layer.</param>
private void CreateChildTileLayer(TmxLayer tmxLayer)
{
var tileMapLayer = new TiledMapLayer(tmxLayer);
this.tileLayers.Add(tmxLayer.Name, tileMapLayer);
Entity layerEntity = new Entity(tmxLayer.Name)
{
IsVisible = tmxLayer.Visible
}
.AddComponent(new Transform2D()
{
Opacity = (float)tmxLayer.Opacity
})
.AddComponent(tileMapLayer)
.AddComponent(new TiledMapLayerRenderer(this.layerType, this.samplerMode));
this.Owner.AddChild(layerEntity);
}
/// <summary>
/// Create the tile layer as a child entity
/// </summary>
/// <param name="tmxLayer">The tmx layer.</param>
/// <param name="layerIndex">The layer index</param>
private void CreateChildTileLayer(TmxLayer tmxLayer, int layerIndex)
{
var tag = "TileLayer_" + layerIndex;
var tmxLayerName = tmxLayer.Name;
Entity layerEntity = null;
TiledMapLayer tileMapLayer = null;
layerEntity = this.Owner.FindChildrenByTag(tag).FirstOrDefault();
var tileLayerOffset = new Vector2((float)tmxLayer.OffsetX, (float)tmxLayer.OffsetY);
if (layerEntity != null)
{
var tileMapTransform = layerEntity.FindComponent<Transform2D>();
tileMapLayer = layerEntity.FindComponent<TiledMapLayer>();
if (tileMapTransform != null
&& tileMapLayer != null)
{
tileMapTransform.LocalPosition = tileLayerOffset;
tileMapLayer.TmxLayerName = tmxLayerName;
layerEntity.Name = tmxLayerName;
}
else
{
this.Owner.RemoveChild(layerEntity.Name);
layerEntity = null;
}
}
if (layerEntity == null)
{
tileMapLayer = new TiledMapLayer()
{
TmxLayerName = tmxLayerName
};
layerEntity = new Entity(tmxLayerName)
{
Tag = tag
}
.AddComponent(tileMapLayer)
.AddComponent(new Transform2D()
{
LocalPosition = tileLayerOffset,
Origin = this.transform.Origin,
Opacity = (float)tmxLayer.Opacity
})
.AddComponent(new TiledMapLayerRenderer());
this.Owner.AddChild(layerEntity);
}
this.tileLayers.Add(tmxLayerName, tileMapLayer);
}
