/// <summary>
/// Gets the specified level layer.
/// </summary>
/// <typeparam name="T">The type of layer to retrieve.</typeparam>
/// <param name="name">The name of the layer.</param>
/// <returns>Returns the specified layer if found; otherwise, <c>null</c>.</returns>
public T GetLayer <T>(string name) where T : OgmoLayer
{
OgmoLayer value = null;
if (layers.TryGetValue(name, out value))
{
return(value as T);
}
return(null);
}
public OgmoLevel(TextAsset xmlFile)
{
name = xmlFile.name;
XmlDocument xml = new XmlDocument ();
xml.LoadXml (xmlFile.text);
XmlElement root = (XmlElement)xml.FirstChild;
width = int.Parse (root.GetAttribute ("width"));
height = int.Parse (root.GetAttribute ("height"));
layers = new Dictionary<string,OgmoLayer> ();
foreach (XmlElement child in root) {
OgmoLayer layer = new OgmoLayer (child, width, height);
layers [layer.name] = layer;
}
}
internal OgmoLevel(ContentReader reader)
{
// Project
this.Project = reader.ReadExternalReference <OgmoProject>();
// Values
int valueCount = reader.ReadInt32();
if (valueCount > 0)
{
for (int i = 0; i < valueCount; i++)
{
OgmoValue value = OgmoValueReader.Read(reader);
if (value != null)
{
values.Add(value.Name, value);
}
}
}
// Height
this.Height = reader.ReadInt32();
// Width
this.Width = reader.ReadInt32();
// Layers
int layerCount = reader.ReadInt32();
if (layerCount > 0)
{
for (int i = 0; i < layerCount; i++)
{
OgmoLayer layer = OgmoLayerReader.Read(reader, this);
if (layer != null)
{
this.layers.Add(layer.Name, layer);
}
}
}
}
protected override void Write(ContentWriter output, OgmoProcessorResult value)
{
// write the number of layer definitions
output.Write(value.Project.Layers.Length);
// Write each layer definition in sequence
for (int i = 0; i < value.Project.Layers.Length; i++)
{
// Write the layer type
output.Write(value.Project.Layers[i].LayerType.ToString());
// Write the layer name
output.Write(value.Project.Layers[i].Name);
}
// Write the number of tilesets
output.Write(value.Project.Tilesets.Length);
// Write each tileset in sequence
for (int tileSetIndex = 0; tileSetIndex < value.Project.Tilesets.Length; tileSetIndex++)
{
// Write the name of the tileset
output.Write(value.Project.Tilesets[tileSetIndex].Label);
// Write the image data for the tileset
output.Write(value.Project.Tilesets[tileSetIndex].Image);
// Write the width of each tile in the tileset
output.Write(value.Project.Tilesets[tileSetIndex].TileWidth);
// Write the height of each tile in the tileset
output.Write(value.Project.Tilesets[tileSetIndex].TileHeight);
// Write the x seperation of each tile in the tileset
output.Write(value.Project.Tilesets[tileSetIndex].TileSeperationX);
// Write the y seperation of each tile in the tileset
output.Write(value.Project.Tilesets[tileSetIndex].TileSeperationY);
}
// Write the number of levels
output.Write(value.Levels.Length);
// Write each level in sequence
for (int levelIndex = 0; levelIndex < value.Levels.Length; levelIndex++)
{
// Write the level name
output.Write(value.Levels[levelIndex].Name);
// Write the level width
output.Write(value.Levels[levelIndex].Width);
// Write the level Height
output.Write(value.Levels[levelIndex].Height);
// Write the level x-offset
output.Write(value.Levels[levelIndex].OffsetX);
// Write the level y-offset
output.Write(value.Levels[levelIndex].OffsetY);
// Write the total number of layers
output.Write(value.Levels[levelIndex].Layers.Length);
// Write each layer in the level in sequence
for (int layerindex = 0; layerindex < value.Levels[levelIndex].Layers.Length; layerindex++)
{
// Get refernece to the layer to make writing code eaiser lol
OgmoLayer layer = value.Levels[levelIndex].Layers[layerindex];
// Get the type of layer from the layer lookup dictionary
OgmoLayerType layerType = value.LayerTypeLookup[layer.Name];
// Write the type of layer
output.Write((int)layerType);
// Write the name of the layer
output.Write(layer.Name);
// Write the x-offset of the layer
output.Write(layer.OffsetX);
// Write the y-offset of the layer
output.Write(layer.OffsetY);
// Write the grid cell width for the layer
output.Write(layer.GridCellWidth);
// Write the grid cell height for the layer
output.Write(layer.GridCellHeight);
// Write the total number of columns in the layer
output.Write(layer.GridCellsX);
// Write the total number of rows in the layer
output.Write(layer.GridCellsY);
// Write the layer type specific properties
if (layerType == OgmoLayerType.Tile)
{
// Write the name of the tileset used by this layer
output.Write(layer.Tileset);
// Write the total number of elements in the layer data
output.Write(layer.Data.Length);
// Write each element of the layer data
for (int dataIndex = 0; dataIndex < layer.Data.Length; dataIndex++)
{
output.Write(layer.Data[dataIndex]);
}
// Write the export mode
output.Write(layer.ExportMode);
// Writ the array mode
output.Write(layer.ArrayMode);
}
}
}
}
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;
}
public override OgmoLevel ReadJson(JsonReader reader, Type objectType, OgmoLevel existingValue, bool hasExistingValue, JsonSerializer serializer)
{
JObject obj = JObject.Load(reader);
OgmoProject project = serializer.Context.Context as OgmoProject;
OgmoValueDefinition[] defs = project.LevelValueDefinitions;
OgmoLevel level = new OgmoLevel();
level.LevelSize = new Point((int)obj["width"], (int)obj["height"]);
level.OgmoVersion = (string)obj["ogmoVersion"];
// Layers.
var layerList = obj["layers"].Children().ToArray();
level.Layers = new OgmoLayer[layerList.Length];
for (int x = 0; x < layerList.Length; x++)
{
OgmoLayer result = (OgmoLayer)OgmoLayerConverter.Instance.ReadJson(layerList[x].CreateReader(), typeof(OgmoLayer), null, serializer);
level.Layers[x] = result;
}
// Values.
var valArray = obj["values"] as JObject;
level.Values = new Dictionary <string, OgmoValue>();
if (valArray == null)
{
return(level);
}
foreach (var pair in valArray)
{
for (int x = 0; x < defs.Length; x++)
{
if (defs[x].Name == pair.Key)
{
var definition = defs[x];
switch (definition)
{
case OgmoColorValueDefinition color:
var colorVal = new OgmoColorValue();
colorVal.Name = pair.Key;
colorVal.Definition = color;
colorVal.Value = ColorExt.HexToColor((string)pair.Value);
level.Values.Add(pair.Key, colorVal);
break;
case OgmoStringValueDefinition str:
var stringVal = new OgmoStringValue();
stringVal.Name = pair.Key;
stringVal.Definition = str;
stringVal.Value = (string)pair.Value;
level.Values.Add(pair.Key, stringVal);
break;
case OgmoEnumValueDefinition enu:
var enumVal = new OgmoEnumValue();
enumVal.Name = pair.Key;
enumVal.Definition = enu;
var enumstring = (string)pair.Value;
enumVal.Value = Array.IndexOf(enu.Choices, enumstring);
level.Values.Add(pair.Key, enumVal);
break;
case OgmoFloatValueDefinition flo:
var floatVal = new OgmoFloatValue();
floatVal.Name = pair.Key;
floatVal.Definition = flo;
floatVal.Value = (float)pair.Value;
level.Values.Add(pair.Key, floatVal);
break;
case OgmoTextValueDefinition text:
var textValue = new OgmoTextValue();
textValue.Name = pair.Key;
textValue.Definition = text;
textValue.Value = (string)pair.Value;
level.Values.Add(pair.Key, textValue);
break;
}
}
}
}
return(level);
}
private void LoadLayer(OgmoLayer layer)
{
if (layer.tiles != null) {
OTContainer container = containers [0];
if (!string.IsNullOrEmpty (layer.tileSet)) {
foreach (var c in containers) {
if (c != null &&
string.Equals (c.name, layer.tileSet, System.StringComparison.InvariantCultureIgnoreCase))
container = c;
}
}
float height = 0f;
switch (layer.name) {
case "Foreground":
height = -5f;
break;
case "Background":
height = 0f;
break;
}
foreach (var tile in layer.tiles) {
LoadTile (tile, container, height);
}
}
if (layer.entities != null) {
foreach (var entity in layer.entities) {
LoadEntity (entity);
}
}
}
