/// <summary>
/// Gets the specified layer settings.
/// </summary>
/// <typeparam name="T">The type of layer settings to retrieve.</typeparam>
/// <param name="name">The name of the layer settings.</param>
/// <returns>Returns the specified layer settings if found; otherwise, <c>null</c>.</returns>
public T GetLayerSettings <T>(string name) where T : OgmoLayerSettings
{
OgmoLayerSettings value = null;
if (layerSettings.TryGetValue(name, out value))
{
return(value as T);
}
return(null);
}
private static void ExtractTileLayer(Layer layer, OgmoLayer olayer, OgmoLayerSettings olayersettings)
{
if (olayer is OgmoTileLayer)
{
var tilelayer = olayer as OgmoTileLayer;
var tilelayersettings = olayersettings as OgmoTileLayerSettings;
if (tilelayersettings.ExportTileIDs == true) throw new ApplicationException("Unsupported option : exportIds=true");
// Create a grid with right options
var tileDim = new Vector2(tilelayersettings.GridSize, tilelayersettings.GridSize);
// We need to know the grid dimension before creating it, but we have to compute it from all tiles...
List<KeyValuePair<Vector2, Tile>> tiles = new List<KeyValuePair<Vector2, Tile>>();
foreach (OgmoTile otile in tilelayer.Tiles)
{
Rectangle source = new Rectangle(otile.TextureOffset.X, otile.TextureOffset.Y, otile.Tileset.TileWidth, otile.Tileset.TileHeight);
if (otile.RectSize != Vector2.Zero)
{
// Create multiple tiles from this one
var tileSize = Grid.WorldToGrid(otile.RectSize, tileDim);
for (int x = 0; x < tileSize.X; x++)
{
for (int y = 0; y < tileSize.Y; y++)
{
Vector2 tileGridLocation = Grid.WorldToGrid(otile.Position, tileDim);
tileGridLocation += new Vector2(x, y);
var newTile = new Tile(otile.Tileset.Name, source);
tiles.Add(new KeyValuePair<Vector2, Tile>(tileGridLocation, newTile));
}
}
}
else
{
Vector2 tileGridLocation = Grid.WorldToGrid(otile.Position, tileDim);
var newTile = new Tile(otile.Tileset.Name, source);
tiles.Add(new KeyValuePair<Vector2, Tile>(tileGridLocation, newTile));
}
}
foreach (KeyValuePair<Vector2, Tile> tile in tiles)
{
layer.Tiles.SetTile(tile.Key, tile.Value);
}
}
}
private static void ExtractObjectLayer(Layer layer, OgmoLayer olayer, OgmoLayerSettings olayersettings)
{
if (olayer is OgmoObjectLayer)
{
var objlayer = olayer as OgmoObjectLayer;
var objlayersettings = olayersettings as OgmoObjectLayerSettings;
foreach (OgmoObject oo in objlayer.Objects)
{
OgmoObjectEntity newObject = null;
if (oo.IsTiled)
{
throw new ArgumentException("Tiled object are not supported !");
////Find template
//foreach (OgmoObjectTemplate template in ogmoLevel.Project.ObjectTemplates)
//{
// if (template.Name == oo.Name)
// {
// newSprite = context.SpriteFactory.CreateSprite(context, oo.Name, oo.Position, oo.Source, new Vector2(template.Width, template.Height));
// break;
// }
//}
}
else
{
newObject = InstanciateOgmoObject(oo);
//newObject = InstanciateOgmoObject(oo.Name, oo.Position, oo.Source);
}
layer.Entities.Add(newObject);
}
}
}
private static List<Rectangle> ExtractGridRectLayer(OgmoLayer olayer, OgmoLayerSettings olayersettings)
{
List<Rectangle> floors = new List<Rectangle>();
if (olayer is OgmoGridLayer)
{
var gridlayer = olayer as OgmoGridLayer;
var gridlayersettings = olayersettings as OgmoGridLayerSettings;
foreach (Rectangle rect in gridlayer.RectangleData)
{
floors.Add(rect);
}
}
return floors;
}
internal OgmoProject(ContentReader reader)
{
// Name
this.Name = reader.ReadString();
// Settings
this.Settings = new OgmoProjectSettings(reader);
// Values
int valueCount = reader.ReadInt32();
if (valueCount > 0)
{
for (int i = 0; i < valueCount; i++)
{
OgmoValueTemplate ogmoValue = OgmoValueTemplateReader.Read(reader);
if (ogmoValue != null)
{
values.Add(ogmoValue.Name, ogmoValue);
}
}
}
// Tilesets
int tilesetCount = reader.ReadInt32();
if (tilesetCount > 0)
{
for (int i = 0; i < tilesetCount; i++)
{
OgmoTileset tileset = new OgmoTileset(reader);
if (tileset != null)
{
tilesets.Add(tileset.Name, tileset);
}
}
}
// Objects
int objectCount = reader.ReadInt32();
if (objectCount > 0)
{
for (int i = 0; i < objectCount; i++)
{
OgmoObjectTemplate obj = new OgmoObjectTemplate(reader);
if (obj != null)
{
objects.Add(obj.Name, obj);
}
}
}
// Layer Settings
int layerSettingsCount = reader.ReadInt32();
if (layerSettingsCount > 0)
{
for (int i = 0; i < layerSettingsCount; i++)
{
OgmoLayerSettings layerSettings = OgmoLayerSettingsReader.Read(reader);
if (layerSettings != null)
{
this.layerSettings.Add(layerSettings.Name, layerSettings);
}
}
}
}
