/// <summary>
/// Add layer.
/// </summary>
/// <param name="layer">ObjectLayer for add.</param>
public void AddLayer(ObjectLayer layer)
{
_objectLayers.Add(layer);
FrameworkElement mapTip = (FrameworkElement)LayoutRoot.FindResource("MapTip");
_mapTips.CreateMapTipIfNeeded(layer, mapTip);
}
private ObjectLayer Execute1stLevelSegmentation(GrayscaleProcessor gp, GrayscaleProcessor gpSobel, GrayscaleProcessor gpH)
{
ContourBasedSegmentation cbs = new ContourBasedSegmentation();
cbs.CreatePrimarySegmentation(gp, MAX_CONTOURLENGTH);
cbs.EvaluateContours(c =>
{
if (ContourProperties.FromContour(c).Convexity < 0.95)
{
return(-1);
}
return(ContourValue.GetValue(c, gpSobel));
});
ObjectLayer layer = cbs.CreateLayer(MIN_CONTOURLENGTH, int.MaxValue);
layer = new ContourOptimizer().RemoveNonCompactPixels(layer, 3);
layer = layer.CreateAbove(obj =>
{
return(this.GetContourGradient(obj, gp) < 0);
});
//layer=new ConcaveObjectSeparation().Execute(layer, 0.33, true);
return(layer);
}
/// <summary>
/// Improve Calc-Function for Lumina
/// </summary>
/// <requred_features>
/// Area
/// </requred_features>
/// <param name="lumina"></param>
/// <returns></returns>
public ObjectLayer ImprObjectLayer(ObjectLayer objectLayerLumina)
{
const double minArea = 500;
var listImageObjects = new List <ImageObject>();
var mapObjectLayerMap = new Map(objectLayerLumina.Map.Width, objectLayerLumina.Map.Height);
foreach (var imageObject in objectLayerLumina.Objects)
{
//Nur Werte Aufnehmen die auch die min. Bedingung erfüllen
if (imageObject.Features.GetFeatureByName("area").Value >= minArea)
{
//In neue Liste eintragen
listImageObjects.Add(ObjectLayerrUtils.CopyImageObject(imageObject.Id, imageObject));
//In neuer Map eintragen
for (var x = 0; x < objectLayerLumina.Map.Width; x++)
{
for (var y = 0; y < objectLayerLumina.Map.Height; y++)
{
if (objectLayerLumina.Map[x, y] == imageObject.Id)
{
mapObjectLayerMap[x, y] = imageObject.Id;
}
}
}
}
}
return(new ObjectLayer(mapObjectLayerMap, listImageObjects.ToArray(), objectLayerLumina.Name));
}
/// <summary>
/// new Feature:
/// area
/// </summary>
/// <param name="objectLayer"></param>
/// <returns></returns>
public static ObjectLayer AddFeatureArea(ObjectLayer objectLayer)
{
var listImageObjects = new List <ImageObject>();
var dicCountPixel = objectLayer.Objects.ToDictionary(imageObject => imageObject.Id, imageObject => 0);
for (var x = 0; x < objectLayer.Map.Width; x++)
{
for (var y = 0; y < objectLayer.Map.Height; y++)
{
if (objectLayer.Map[x, y] != 0)
{
dicCountPixel[objectLayer.Map[x, y]]++;
}
}
}
foreach (var imageObject in objectLayer.Objects)
{
var item = CopyImageObject(imageObject.Id, imageObject);
item.Features.Add(new Feature("area", dicCountPixel[imageObject.Id]));
listImageObjects.Add(item);
}
return(new ObjectLayer(objectLayer.Map, listImageObjects.ToArray(), objectLayer.Name));
}
public ObjectPointerTool(ILayerContext layerContext, ObjectLayer layer, Size gridSize)
{
_layerContext = layerContext;
//_history = history;
_layer = layer;
_gridSize = gridSize;
}
/// <summary>
/// Create layer for showing unassigned orders of current schedule.
/// </summary>
private void _CreateUnassignedLayer()
{
_unassignedLayer = new ObjectLayer(_unassignedOrdersColl, typeof(Order), true, _stopOrdersLayer.MapLayer);
_unassignedLayer.EnableToolTip();
mapCtrl.AddLayer(_unassignedLayer);
_unassignedLayer.Selectable = true;
}
private ObjectLayer GetObjectLayerFromFilterLayer(string filter_layer)
{
ObjectLayer objectLayer = ObjectLayer.NumLayers;
switch (filter_layer.ToLower())
{
case "buildings":
return(ObjectLayer.Building);
case "wires":
return(ObjectLayer.Wire);
case "liquidpipes":
return(ObjectLayer.LiquidConduit);
case "gaspipes":
return(ObjectLayer.GasConduit);
case "solidconduits":
return(ObjectLayer.SolidConduit);
case "tiles":
return(ObjectLayer.FoundationTile);
case "logic":
return(ObjectLayer.LogicWires);
case "backwall":
return(ObjectLayer.Backwall);
default:
throw new ArgumentException("Invalid filter layer: " + filter_layer);
}
}
/// <summary>
/// get necessary data for layers in a region
/// </summary>
/// <param name="layers">requested layers, namely agent, primitive and terrain</param>
public void initialize(string[] layers)
{
m_hasAgentLyr = false;
m_hasObjLyr = false;
m_hasTerrainLyr = false;
for (int i = 0; i < layers.Length; i++)
{
switch (layers[i])
{
case "agent":
m_agentLyr = new AgentLayer(m_scene);
m_agentLyr.initialize();
m_hasAgentLyr = true;
break;
case "primitive":
m_objLyr = new ObjectLayer(m_scene);
m_objLyr.initialize();
m_hasObjLyr = true;
break;
case "terrain":
m_terrainLyr = new TerrainLayer(m_scene);
m_terrainLyr.initialize();
m_hasTerrainLyr = true;
break;
default:
break;
}
}
}
/// <summary>
/// Set markers layer.
/// </summary>
/// <param name="markersLayer">Parent map control markers layer.</param>
public void SetLayer(ObjectLayer markersLayer)
{
Debug.Assert(_markersLayer == null);
Debug.Assert(markersLayer != null);
_markersLayer = markersLayer;
}
/// <summary>
/// Create RegionsPage.
/// </summary>
/// <param name="mapCtrl">Map from parent page.</param>
/// <param name="dataGridControl">Grid from parent page.</param>
/// <param name="parentLayer">Layer, that contains regions.</param>
/// <param name="type">Semantic type of regions. Barrier or Zone.</param>
/// <param name="layoutRoot">Parent page layout root.</param>
/// <param name="mapBorder">Container element for map.</param>
public RegionsPage(MapControl mapCtrl, DataGridControlEx dataGridControl, ObjectLayer parentLayer,
Type type, Grid layoutRoot, Border mapBorder)
{
_mapCtrl = mapCtrl;
_mapCtrl.CanSelectCallback = _CanSelect;
_mapCtrl.StartEditRegionCallback = _EditStarted;
_mapCtrl.EndEditRegionCallback = _EditEnded;
_dataGridControl = dataGridControl;
_parentLayer = parentLayer;
_type = type;
if (_type == typeof(Zone))
{
_polygonTool = new ZonePolygonTool();
_polygonTool.OnComplete += new EventHandler(_PolygonToolOnComplete);
_mapCtrl.AddTool(_polygonTool, _CanActivateZonePolygonTool);
}
else if (_type == typeof(Barrier))
{
_CreateBarrierTools();
}
else
{
Debug.Assert(false);
}
_gridAutoFitHelper = new GridAutoFitHelper(dataGridControl, layoutRoot, mapBorder);
}
/// <summary>
/// Create layer for showing stops associated with orders of current schedule.
/// </summary>
private void _CreateStopOrdersLayer()
{
_stopOrdersLayer = new ObjectLayer(_stopOrders, typeof(Stop), true);
_stopOrdersLayer.EnableToolTip();
_stopOrdersLayer.Selectable = true;
mapCtrl.AddLayer(_stopOrdersLayer);
}
private void LoadFriends(ObjectLayer a_friendLayer)
{
foreach (MapObject friend in a_friendLayer.MapObjects)
{
m_friends.Add(new Friend(friend, Convert.ToInt32(friend.Properties["ID"].AsInt32), Convert.ToBoolean(friend.Properties["CanInterract"].AsBoolean)));
}
}
/// <summary>
/// Create layer for showing routes of current schedule.
/// </summary>
private void _CreateRoutesLayer()
{
_routesLayer = new ObjectLayer(_routesColl, typeof(Route), false);
_routesLayer.EnableToolTip();
mapCtrl.AddLayer(_routesLayer);
_routesLayer.Selectable = true;
}
/// <summary>
/// Create layer for showing stops associated with locations of current schedule.
/// </summary>
private void _CreateStopLocationsLayer()
{
_stopLocationsLayer = new ObjectLayer(_stopLocations, typeof(Stop), false);
_stopLocationsLayer.EnableToolTip();
_stopLocationsLayer.Selectable = true;
mapCtrl.AddLayer(_stopLocationsLayer);
}
private ObjectLayer ProcessObjectLayer(ObjectLayer layer, ObjectPool objectLayerPool)
{
ObjectLayer outLayer = new ObjectLayer(layer.Name, layer.LayerOriginX, layer.LayerOriginY, layer.LayerWidth, layer.LayerHeight)
{
IsVisible = layer.IsVisible,
Opacity = layer.Opacity,
RasterMode = layer.RasterMode,
};
foreach (Property prop in layer.PropertyManager.CustomProperties)
{
outLayer.PropertyManager.CustomProperties.Add(prop);
}
foreach (ObjectInstance obj in layer.Objects)
{
if (!objectLayerPool.Objects.Contains(obj.ObjectClass.Uid))
{
objectLayerPool.Objects.Add(obj.ObjectClass);
}
outLayer.AddObject(obj);
}
return(outLayer);
}
/// <summary>
/// erzeugt einen WEKA-kompatiblen Datensatz aus einem <see cref="ObjectLayer"/>
/// </summary>
/// <param name="objectLayer"><see cref="ObjectLayer"/></param>
/// <param name="classNames">Aufzählung der Klassennamen die im Datensatz verwendet werden sollen</param>
/// <param name="classAttributeName">>Name für das Klassenattribut</param>
/// <returns>Datensatz</returns>
public static Instances CreateWekaData(this ObjectLayer objectLayer, IEnumerable <string> classNames, string classAttributeName = "class")
{
var instances = Util.CreateInstances(classNames, objectLayer.FindContainedFeatures(), objectLayer.Name, classAttributeName);
instances.AddImageObjects(objectLayer);
return(instances);
}
public void ObjectTest()
{
AddressBook.ObjectLayer obLayer = new ObjectLayer();
Person person = new Person(0, "A", "B", 27074358, 27074358);
obLayer.CheckIC(person.IC);
}
/// <summary>
/// Load all the bush objects into the world.
/// </summary>
/// <param name="bushes"></param>
private void LoadBushes(ObjectLayer bushes)
{
int count = 0;
foreach (var mapObject in bushes.MapObjects)
{
int x = mapObject.Bounds.X,
y = mapObject.Bounds.Y;
int tileX = x / TileWidth,
tileY = y / TileHeight;
var position = new Vector2(x - mapObject.Bounds.Width / 2f, y - mapObject.Bounds.Height / 2f);
var bush = new Bush(position, WorldObjectAnimations, "/Bush/Green/Idle");
if (Objects[tileX, tileY] == null)
{
Objects[tileX, tileY] = new List <GameObject>();
}
Objects[tileX, tileY].Add(bush);
count++;
}
Log.Debug(" + {0} bushes.", count);
}
private float GetTargetArea(ObjectLayer layer)
{
if (layer.Objects.Count == 0)
{
return(-1);
}
float targetArea = -1F;
List <float> values = new List <float>();
for (int i = 0; i < layer.Objects.Count; i++)
{
ImageObject obj = layer.Objects[i];
float area = ContourProperties.FromContour(obj.Contour).Area;
values.Add(area);
}
values.Sort();
int index = (int)(0.95 * values.Count);
if (values.Count > 0)
{
targetArea = values[index];
}
return(targetArea);
}
/// <summary>
/// Loads npc objects from the tmx map
/// </summary>
/// <param name="npcLayer"></param>
private void LoadFriends(ObjectLayer npcLayer)
{
foreach (MapObject friend in npcLayer.MapObjects)
{
_nonPlayerCharacters.Add(new NonPlayerCharacter(friend, Convert.ToInt32(friend.Properties["ID"].AsInt32), Convert.ToBoolean(friend.Properties["CanInterract"].AsBoolean)));
}
}
/// <summary>
/// fügt alle <see cref="ImageObject"/>s des <see cref="ObjectLayer"/> zu den <see cref="Instances"/> hinzu
/// </summary>
/// <param name="instances">Datensatz</param>
/// <param name="objectLayer">auszuwertender <see cref="ObjectLayer"/></param>
public static void AddImageObjects(this Instances instances, ObjectLayer objectLayer)
{
foreach (var io in objectLayer.Objects)
{
instances.CreateWekaInstance(io);
}
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
map = Content.Load <Map>("Level1/Level1");
customCursor = Content.Load <Texture2D>("mouseCursor");
AspectRatio = GraphicsDevice.Viewport.AspectRatio;
OldWindowSize = new Point(Window.ClientBounds.Width, Window.ClientBounds.Height);
BlankTexture = new Texture2D(GraphicsDevice, 1, 1);
BlankTexture.SetData(new Color[] { Color.FromNonPremultiplied(255, 255, 255, 255) });
spriteBatch = new SpriteBatch(GraphicsDevice);
OffScreenRenderTarget = new RenderTarget2D(GraphicsDevice, Window.ClientBounds.Width, Window.ClientBounds.Height);
hud.LoadContent(Content);
this.collisionLayer = this.map.ObjectLayers["Collision"];
player.LoadContent(Content, "hero", mapView, collisionLayer);
// Setting player position.
this.objLayer = this.map.ObjectLayers["Objects"];
MapObject mapObj = this.objLayer.MapObjects.Where(p => p.Name.Equals("SpawnPoint", StringComparison.CurrentCultureIgnoreCase)).Select(p => p).First();
// Verificaion.
if (mapObj != null)
{
// Get coordinates.
Rectangle pos = Map.Translate(mapObj.Bounds, this.mapView);
player.position = new Vector2(pos.X, pos.Y);
}
// TODO: use this.Content to load your game content here
}
public FacilityObject ObjectAt(XYZ location, ObjectLayer layer)
{
if (!_objects.ContainsKey(location))
{
return(new FacilityObject());
}
return(_objects[location].First(x => x.ObjectLayer == layer));
}
public ObjectOrderCommand(ObjectLayer source)
{
_objectSource = source;
_objects = new List <ObjectRecord>();
_toFront = new List <ObjectInstance>();
_toBack = new List <ObjectInstance>();
}
/// <summary>
/// Retrieves an object layer by its name, resolving the value at runtime to handle
/// differences in the layer enum. This method is slower than a direct lookup -
/// consider caching the result.
/// </summary>
/// <param name="name">The name of the layer (use nameof()!)</param>
/// <param name="defValue">The default value (use the value at compile time)</param>
/// <returns>The value to use for this object layer.</returns>
public static ObjectLayer GetObjectLayer(string name, ObjectLayer defValue)
{
if (!Enum.TryParse(name, out ObjectLayer value))
{
value = defValue;
}
return(value);
}
/// <summary>
/// Create layer for showing ungeocoded orders.
/// </summary>
private void _CreateOrdersLayer()
{
_ordersLayer = new ObjectLayer(new List <Order>(), typeof(Order), false);
_ordersLayer.EnableToolTip();
_ordersLayer.Selectable = false;
mapCtrl.AddLayer(_ordersLayer);
}
public EnemySystem(ObjectLayer a_enemyLayer, Level a_level, Map a_currentMap)
{
m_enemies = new List <Model.Enemy>();
m_spawnList = new List <Enemy>();
m_enemySpellSystem = new SpellSystem();
m_enemyId = 0;
LoadEnemies(a_enemyLayer, a_level, a_currentMap);
}
//Is not network synced, is used for prediction on local client when walking between matricies
public void SetParentOnLocal(Transform newParent)
{
Unregister();
layer = newParent.GetComponentInChildren <ObjectLayer>();
Matrix = newParent.GetComponent <Matrix>();
transform.parent = layer.transform;
Register();
}
public virtual void Start()
{
position = Vector3Int.FloorToInt(transform.localPosition);
layer = transform.parent.GetComponent <ObjectLayer>();
layer.Objects.Add(position, this);
}
private void Start()
{
metaTileMap = GetComponentInChildren <MetaTileMap>();
matrix = GetComponentInChildren <Matrix>();
objectLayer = GetComponentInChildren <ObjectLayer>();
tileChangeManager = GetComponent <TileChangeManager>();
CacheTileMaps();
}
public static void ProcessLayer(ObjectLayer layer,Point location)
{
Contract.Requires(null!=layer);
for(var i=0;i<layer.Objects.Count;i++) {
if(layer.Objects[i].Features.Contains(CentroidX.Name)&&layer.Objects[i].Features.Contains(CentroidY.Name)) continue;
double[] centroid=Centroid.getCentroid(layer.Objects[i]);
layer.Objects[i].Features.Add(new CentroidX(centroid[0]+location.X));
layer.Objects[i].Features.Add(new CentroidY(centroid[1]+location.Y));
}
}
private static void DrawObjectsToImage(Bitmap bitmap, ObjectLayer layer, Color color)
{
//*** Exception, falls eines der Parameter null ist **********************************************
if (bitmap == null || layer == null || color == null) { throw new NullReferenceException("Parameter ungültig!"); }
//*** Exception, falls Bild und Objektebene unterschiedliche Dimension haben *********************
if (bitmap.Width != layer.Map.Width || bitmap.Height != layer.Map.Height) { throw new ArgumentOutOfRangeException("bitmap"); }
//*** Bildprozessor anlegen **********************************************************************
using (var processor = new BitmapProcessor(bitmap))
{
//*** Über alle Konturpunkte der Objekte iterieren *******************************************
foreach (Point point in layer.Objects.ToArray().SelectMany(imageObject => imageObject.Contour.GetPoints()))
{
//*** Konturpunkt im Bild auf gegebene Farbe setzen **************************************
processor.SetRed(point.X, point.Y, color.R);
processor.SetGreen(point.X, point.Y, color.G);
processor.SetBlue(point.X, point.Y, color.B);
}
}
}
private ObjectLayer Execute3rdLevelSegmentation(ObjectLayer l2ndLevel, GrayscaleProcessor gpSobel, GrayscaleProcessor gpH, float targetArea)
{
List<Contour> finalContours = new List<Contour>();
for (int i = 0; i < l2ndLevel.Objects.Count; i++)
{
finalContours.Add(l2ndLevel.Objects[i].Contour);
}
double[] hBackground = this.GetBackgroundHistogram(l2ndLevel, gpH);
double[] hForeground = this.GetForegroundHistogram(l2ndLevel, gpH);
Parallel.For(0, l2ndLevel.Objects.Count, i =>
{
ImageObject obj = l2ndLevel.Objects[i];
ContourProperties cp = ContourProperties.FromContour(obj.Contour);
obj.Features.Add(new Feature("Area", cp.Area));
});
Map map = new Map(gpSobel.Width, gpSobel.Height);
Parallel.For(0, gpH.Height, dy =>
{
for (int dx = 0; dx < gpH.Width; dx++)
{
UInt32 h = gpH[dx, dy];
if (hForeground[h] <= hBackground[h]) continue;
UInt32 id = l2ndLevel.Map[dx, dy];
if (id != 0)
{
ImageObject obj = l2ndLevel.Objects.GetObjectById(id);
double area = obj.Features["Area"].Value;
if (area > 0.33 * targetArea) continue;
}
map[dx, dy] = 0xffffffff;
}
});
ObjectLayer layer = new ConnectedComponentCollector().Execute(map);
layer = new ContourOptimizer().RemoveNonCompactPixels(layer, 3);
for (int i = 0; i < layer.Objects.Count; i++)
{
finalContours.Add(layer.Objects[i].Contour);
}
Contour[] contours = this.Sort(finalContours.ToArray(), gpSobel, gpH, targetArea);
layer = this.CreateLayer(gpSobel.Width, gpSobel.Height, contours);
Map finalMap = new Map(layer.Map, false);
for (int dy = 0; dy < gpH.Height; dy++) for (int dx = 0; dx < gpH.Width; dx++)
{
if (l2ndLevel.Map[dx, dy] != 0) continue;
if (map[dx, dy] != 0) continue;
finalMap[dx, dy] = 0;
}
layer = new ConnectedComponentCollector().Execute(finalMap);
layer = new ContourOptimizer().RemoveNonCompactPixels(layer, 3);
layer = new ConcaveObjectSeparation().Execute(layer, 0.33, true);
double minArea = Math.Max(0.1 * targetArea, MIN_AREA);
layer = layer.CreateAbove(obj =>
{
float area = ContourProperties.FromContour(obj.Contour).Area;
return area > minArea;
});
layer = this.RefillContours(layer);
return layer;
}
private float GetTargetArea(ObjectLayer layer)
{
if (layer.Objects.Count == 0) return -1;
float targetArea = -1F;
List<float> values = new List<float>();
for (int i = 0; i < layer.Objects.Count; i++)
{
ImageObject obj = layer.Objects[i];
float area = ContourProperties.FromContour(obj.Contour).Area;
values.Add(area);
}
values.Sort();
int index = (int)(0.95 * values.Count);
if (values.Count > 0) targetArea = values[index];
return targetArea;
}
private ObjectLayer RefillContours(ObjectLayer layer)
{
Map map = new Map(layer.Map.Width, layer.Map.Height);
for (int i = 0; i < layer.Objects.Count; i++)
{
ImageObject obj = layer.Objects[i];
obj.Contour.Fill(map, obj.Id, true);
}
layer = new ConnectedComponentCollector().Execute(map);
return layer;
}
private double[] GetBackgroundHistogram(ObjectLayer layer, GrayscaleProcessor p)
{
Map map = new Map(p.Width, p.Height);
for (int dy = 0; dy < p.Height; dy++) for (int dx = 0; dx < p.Width; dx++)
{
if (layer.Map[dx, dy] == 0) map[dx, dy] = 1;
}
double[,] distanceMap = new DistanceTransformation().Execute(map);
double[] histogram = new double[256];
for (int dy = 0; dy < p.Height; dy++) for (int dx = 0; dx < p.Width; dx++)
{
if (map[dx, dy] == 0) continue;
if (distanceMap[dx, dy] < 3) continue;
histogram[p[dx, dy]]++;
}
return histogram;
}
private double[] GetForegroundHistogram(ObjectLayer layer, GrayscaleProcessor p)
{
double[] histogram = new double[256];
Parallel.For(0, layer.Objects.Count, i =>
{
int[] objHistogram = this.GetHistogram(layer.Objects[i], p);
lock (histogram)
{
for (int j = 0; j < 256; j++)
{
int value = objHistogram[j];
histogram[j] += value;
}
}
});
return histogram;
}
public static void ProcessLayer(ObjectLayer layer)
{
Contract.Requires(null!=layer);
ProcessLayer(layer,new Point(0,0));
}
public Map(XDocument xDocument)
{
version = null;
orientation = Orientation.Orthogonal;
width = 0;
height = 0;
tileWidth = 0;
tileHeight = 0;
backgroundColor = Color.black;
XElement xMap = xDocument.Element("map");
foreach (XAttribute xAttribute in xMap.Attributes())
switch (xAttribute.Name.ToString())
{
case "version":
version = (string)xAttribute;
break;
case "orientation":
orientation = (Orientation)Enum.Parse(typeof(Orientation), (string)xAttribute, true);
break;
case "width":
width = (int)xAttribute;
break;
case "height":
height = (int)xAttribute;
break;
case "tilewidth":
tileWidth = (int)xAttribute;
break;
case "tileheight":
tileHeight = (int)xAttribute;
break;
case "backgroundcolor":
backgroundColor = ConvertXColor((string)xAttribute);
break;
}
Tileset tileset;
int tilesetLength;
int tilesetIndex;
TileLayer tileLayer;
ObjectLayer objectLayer;
ImageLayer imageLayer;
List<Tileset> tilesetsList = new List<Tileset>();
List<TileLayer> tileLayersList = new List<TileLayer>();
List<ObjectLayer> objectLayersList = new List<ObjectLayer>();
List<ImageLayer> imageLayersList = new List<ImageLayer>();
List<ILayer> layersList = new List<ILayer>();
List<Property> propertyList = new List<Property>();
foreach (XElement xElement in xMap.Elements())
switch (xElement.Name.ToString())
{
case "tileset":
tileset = new Tileset(xElement);
tilesetLength = tilesetsList.Count;
if (tilesetLength == 0)
tilesetsList.Add(tileset);
else
{
tilesetIndex = tilesetLength;
while (tilesetIndex-- > 0)
if (tilesetIndex == 0)
tilesetsList.Insert(0, tileset);
else if (tileset.firstGID > tilesetsList[tilesetIndex].firstGID)
{
if (tilesetIndex == tilesetLength - 1)
tilesetsList.Add(tileset);
else
tilesetsList.Insert(tilesetIndex + 1, tileset);
}
}
break;
case "layer":
tileLayer = new TileLayer(xElement, width, height);
tileLayersList.Add(tileLayer);
layersList.Add(tileLayer);
break;
case "objectgroup":
objectLayer = new ObjectLayer(xElement);
objectLayersList.Add(objectLayer);
layersList.Add(objectLayer);
break;
case "imagelayer":
imageLayer = new ImageLayer(xElement);
imageLayersList.Add(imageLayer);
layersList.Add(imageLayer);
break;
case "properties":
propertyList.AddRange(ConvertXProperties(xElement));
break;
}
tilesets = tilesetsList.ToArray();
tileLayers = tileLayersList.ToArray();
objectLayers = objectLayersList.ToArray();
imageLayers = imageLayersList.ToArray();
layers = layersList.ToArray();
properties = propertyList.ToArray();
}
