public static void AddCollisionFrom(this TileShapeCollection tileShapeCollection,
LayeredTileMap layeredTileMap, Dictionary <string, TileMapInfo> tileMapInfos)
{
var stringEnum = tileMapInfos.Values.Where(item => item.HasCollision).Select(item => item.Name);
tileShapeCollection.AddCollisionFrom(layeredTileMap, stringEnum);
}
public static TileNodeNetwork CreateFromNames(LayeredTileMap layeredTileMap, DirectionalType directionalType,
ICollection <string> names)
{
Func <List <TMXGlueLib.DataTypes.NamedValue>, bool> predicate = (list) =>
{
var toReturn = false;
foreach (var namedValue in list)
{
if (namedValue.Name == "Name")
{
var valueAsString = namedValue.Value as string;
if (!string.IsNullOrEmpty(valueAsString) && names.Contains(valueAsString))
{
toReturn = true;
break;
}
}
}
return(toReturn);
};
return(CreateFrom(layeredTileMap, directionalType, predicate));
}
protected override void Load(FlatRedBall.Glue.IO.FilePath fileName, out object runtimeObjects, out object dataModel)
{
bool shouldCreate = fileName.Extension == "tmx";
if (shouldCreate && fileName.Exists())
{
//var layeredTileMap = new LayeredTileMap();
// todo load it
string contentManagerName = nameof(TiledRuntimeFileManager);
var tiledMapSave = TiledMapSave.FromFile(fileName.FullPath);
var layeredTileMap =
LayeredTileMap.FromTiledMapSave(fileName.FullPath, contentManagerName, tiledMapSave);
layeredTileMap.Name = fileName.FullPath;
runtimeObjects = layeredTileMap;
dataModel = tiledMapSave;
}
else
{
runtimeObjects = null;
dataModel = null;
}
}
public static void FillFromTypes(this TileNodeNetwork tileNodeNetwork, LayeredTileMap layeredTileMap, DirectionalType directionalType, ICollection <string> types)
{
bool CreateFromTypesPredicate(List <NamedValue> list)
{
var toReturn = false;
foreach (var namedValue in list)
{
if (namedValue.Name == "Type")
{
var valueAsString = namedValue.Value as string;
if (!string.IsNullOrEmpty(valueAsString) && types.Contains(valueAsString))
{
toReturn = true;
break;
}
}
}
return(toReturn);
}
tileNodeNetwork.FillFromPredicate(layeredTileMap, CreateFromTypesPredicate);
}
public static void CreateEntitiesFrom(LayeredTileMap layeredTileMap, InstantiationRestrictions restrictions = null)
{
if (layeredTileMap != null)
{
var entitiesToRemove = new List <string>();
foreach (var layer in layeredTileMap.MapLayers)
{
CreateEntitiesFrom(entitiesToRemove, layer, layeredTileMap.TileProperties, layeredTileMap.WidthPerTile ?? 16, restrictions);
}
if (CurrentSettings.RemoveTileObjectsAfterEntityCreation)
{
foreach (var entityToRemove in entitiesToRemove)
{
string remove = entityToRemove;
layeredTileMap.RemoveTiles(t => t.Any(item => (item.Name == "EntityToCreate" || item.Name == "Type") && item.Value as string == remove), layeredTileMap.TileProperties);
}
}
foreach (var shapeCollection in layeredTileMap.ShapeCollections)
{
CreateEntitiesFromCircles(layeredTileMap, shapeCollection, restrictions);
CreateEntitiesFromRectangles(layeredTileMap, shapeCollection, restrictions);
CreateEntitiesFromPolygons(layeredTileMap, shapeCollection, restrictions);
}
}
}
private static void CreateEntitiesFromCircles(LayeredTileMap layeredTileMap, ShapeCollection shapeCollection)
{
var circles = shapeCollection.Circles;
for (int i = circles.Count - 1; i > -1; i--)
{
var circle = circles[i];
if (!string.IsNullOrEmpty(circle.Name) && layeredTileMap.ShapeProperties.ContainsKey(circle.Name))
{
var properties = layeredTileMap.ShapeProperties[circle.Name];
var entityAddingProperty = properties.FirstOrDefault(item => item.Name == "EntityToCreate" || item.Name == "Type");
var entityType = entityAddingProperty.Value as string;
if (!string.IsNullOrEmpty(entityType))
{
IEntityFactory factory = GetFactory(entityType);
var entity = factory.CreateNew(null) as PositionedObject;
entity.Name = circle.Name;
ApplyPropertiesTo(entity, properties, circle.Position);
shapeCollection.Circles.Remove(circle);
if (entity is Math.Geometry.ICollidable)
{
var entityCollision = (entity as Math.Geometry.ICollidable).Collision;
entityCollision.Circles.Add(circle);
circle.AttachTo(entity, false);
}
}
}
}
}
public static void AddCollisionFrom(this TileShapeCollection tileShapeCollection,
LayeredTileMap layeredTileMap, string nameToUse)
{
AddCollisionFrom(tileShapeCollection, layeredTileMap,
new List <string> {
nameToUse
});
}
public static TileNodeNetwork CreateFrom(LayeredTileMap layeredTileMap, DirectionalType directionalType,
Func <List <TMXGlueLib.DataTypes.NamedValue>, bool> predicate)
{
var numberOfTilesWide =
MathFunctions.RoundToInt(layeredTileMap.Width / layeredTileMap.WidthPerTile.Value);
var numberOfTilesTall =
MathFunctions.RoundToInt(layeredTileMap.Height / layeredTileMap.HeightPerTile.Value);
var tileWidth = layeredTileMap.WidthPerTile.Value;
var dimensionHalf = tileWidth / 2.0f;
TileNodeNetwork nodeNetwork = new TileNodeNetwork(
0 + dimensionHalf,
-layeredTileMap.Height + tileWidth / 2.0f,
tileWidth,
numberOfTilesWide,
numberOfTilesTall,
directionalType);
var properties = layeredTileMap.TileProperties;
foreach (var kvp in properties)
{
string name = kvp.Key;
var namedValues = kvp.Value;
if (predicate(namedValues))
{
foreach (var layer in layeredTileMap.MapLayers)
{
var dictionary = layer.NamedTileOrderedIndexes;
if (dictionary.ContainsKey(name))
{
var indexList = dictionary[name];
foreach (var index in indexList)
{
float left;
float bottom;
layer.GetBottomLeftWorldCoordinateForOrderedTile(index, out left, out bottom);
var centerX = left + dimensionHalf;
var centerY = bottom + dimensionHalf;
nodeNetwork.AddAndLinkTiledNodeWorld(centerX, centerY);
}
}
}
}
}
nodeNetwork.Visible = true;
return(nodeNetwork);
}
public static void AddCollisionFrom(this TileShapeCollection tileShapeCollection,
LayeredTileMap layeredTileMap)
{
var tilesWithCollision = layeredTileMap.TileProperties
.Where(item => item.Value.Any(property => property.Name == "HasCollision" && (string)property.Value == "True"))
.Select(item => item.Key).ToList();
tileShapeCollection.AddCollisionFrom(layeredTileMap, tilesWithCollision);
}
public static TileNodeNetwork CreateFrom(LayeredTileMap layeredTileMap, DirectionalType directionalType,
Func <List <TMXGlueLib.DataTypes.NamedValue>, bool> predicate)
{
TileNodeNetwork nodeNetwork = CreateTileNodeNetwork(layeredTileMap, directionalType);
FillFromPredicate(nodeNetwork, layeredTileMap, predicate);
nodeNetwork.Visible = true;
return(nodeNetwork);
}
public static void AddCollisionFrom(this TileShapeCollection tileShapeCollection,
LayeredTileMap layeredTileMap, IEnumerable <string> namesToUse)
{
Func <List <TMXGlueLib.DataTypes.NamedValue>, bool> predicate = (list) =>
{
var nameProperty = list.FirstOrDefault(item => item.Name.ToLower() == "name");
return(namesToUse.Contains(nameProperty.Value));
};
AddCollisionFrom(tileShapeCollection, layeredTileMap, predicate);
}
/// <summary>
/// Creates entities from a single layer for any tile with the EntityToCreate property.
/// </summary>
/// <param name="mapLayer">The layer to create entities from.</param>
/// <param name="layeredTileMap">The map which contains the mapLayer instance.</param>
public static void CreateEntitiesFrom(MapDrawableBatch mapLayer, LayeredTileMap layeredTileMap)
{
var entitiesToRemove = new List <string>();
CreateEntitiesFrom(entitiesToRemove, mapLayer, layeredTileMap.TileProperties);
foreach (var entityToRemove in entitiesToRemove)
{
string remove = entityToRemove;
mapLayer.RemoveTiles(t => t.Any(item => (item.Name == "EntityToCreate" || item.Name == "Type") && item.Value as string == remove), layeredTileMap.TileProperties);
}
}
public static void CreateEntitiesFrom(LayeredTileMap layeredTileMap, IEnumerable <TileMapInfo> tileMapInfos)
{
// prob need to clear out the tileShapeCollection
var entitiesToRemove = new List <string>();
foreach (var layer in layeredTileMap.MapLayers)
{
CreateEntitiesFrom(entitiesToRemove, layer, tileMapInfos);
}
foreach (var entityToRemove in entitiesToRemove)
{
string remove = entityToRemove;
layeredTileMap.RemoveTiles(t => t.EntityToCreate == remove, tileMapInfos);
}
}
/// <summary>
/// Creates entities from a single layer for any tile with the EntityToCreate property.
/// </summary>
/// <param name="mapLayer">The layer to create entities from.</param>
/// <param name="layeredTileMap">The map which contains the mapLayer instance.</param>
public static void CreateEntitiesFrom(MapDrawableBatch mapLayer, LayeredTileMap layeredTileMap)
{
var entitiesToRemove = new List <string>();
CreateEntitiesFrom(entitiesToRemove, mapLayer, layeredTileMap.TileProperties, layeredTileMap.WidthPerTile ?? 16);
if (CurrentSettings.RemoveTileObjectsAfterEntityCreation)
{
foreach (var entityToRemove in entitiesToRemove)
{
string remove = entityToRemove;
mapLayer.RemoveTiles(t => t.Any(item => (item.Name == "EntityToCreate" || item.Name == "Type") && item.Value as string == remove), layeredTileMap.TileProperties);
}
}
}
public static void CreateEntitiesFrom(LayeredTileMap layeredTileMap, IEnumerable<TileMapInfo> tileMapInfos)
{
// prob need to clear out the tileShapeCollection
var entitiesToRemove = new List<string>();
foreach (var layer in layeredTileMap.MapLayers)
{
CreateEntitiesFrom(entitiesToRemove, layer, tileMapInfos);
}
foreach (var entityToRemove in entitiesToRemove)
{
string remove = entityToRemove;
layeredTileMap.RemoveTiles(t => t.EntityToCreate == remove, tileMapInfos);
}
}
public static void CreateEntitiesFrom(LayeredTileMap layeredTileMap)
{
var entitiesToRemove = new List<string>();
foreach (var layer in layeredTileMap.MapLayers)
{
CreateEntitiesFrom(entitiesToRemove, layer, layeredTileMap.TileProperties);
}
foreach (var entityToRemove in entitiesToRemove)
{
string remove = entityToRemove;
layeredTileMap.RemoveTiles(t => t.Any(item => (item.Name == "EntityToCreate" || item.Name == "Type") && item.Value as string == remove), layeredTileMap.TileProperties);
}
foreach (var shapeCollection in layeredTileMap.ShapeCollections)
{
var polygons = shapeCollection.Polygons;
for (int i = polygons.Count - 1; i > -1; i--)
{
var polygon = polygons[i];
if (!string.IsNullOrEmpty(polygon.Name) && layeredTileMap.ShapeProperties.ContainsKey(polygon.Name))
{
var properties = layeredTileMap.ShapeProperties[polygon.Name];
var entityAddingProperty = properties.FirstOrDefault(item => item.Name == "EntityToCreate");
var entityType = entityAddingProperty.Value as string;
if (!string.IsNullOrEmpty(entityType))
{
IEntityFactory factory = GetFactory(entityType);
var entity = factory.CreateNew(null) as PositionedObject;
entity.Name = polygon.Name;
ApplyPropertiesTo(entity, properties, polygon.Position);
shapeCollection.Polygons.Remove(polygon);
if (entity is Math.Geometry.ICollidable)
{
var entityCollision = (entity as Math.Geometry.ICollidable).Collision;
entityCollision.Polygons.Add(polygon);
polygon.AttachTo(entity, false);
}
}
}
}
}
}
private static void CreateEntitiesFromPolygons(LayeredTileMap layeredTileMap, Math.Geometry.ShapeCollection shapeCollection, InstantiationRestrictions restrictions)
{
var polygons = shapeCollection.Polygons;
for (int i = polygons.Count - 1; i > -1; i--)
{
var polygon = polygons[i];
if (!string.IsNullOrEmpty(polygon.Name) && layeredTileMap.ShapeProperties.ContainsKey(polygon.Name))
{
var properties = layeredTileMap.ShapeProperties[polygon.Name];
var entityAddingProperty = properties.FirstOrDefault(item => item.Name == "EntityToCreate" || item.Name == "Type");
var entityType = entityAddingProperty.Value as string;
var shouldCreate = !string.IsNullOrEmpty(entityType);
if (restrictions?.InclusiveList != null)
{
shouldCreate = restrictions.InclusiveList.Contains(entityType);
}
if (shouldCreate)
{
IEntityFactory factory = GetFactory(entityType);
if (factory != null)
{
var entity = factory.CreateNew(null) as PositionedObject;
entity.Name = polygon.Name;
ApplyPropertiesTo(entity, properties, polygon.Position);
if (CurrentSettings.RemoveTileObjectsAfterEntityCreation)
{
shapeCollection.Polygons.Remove(polygon);
}
if (entity is Math.Geometry.ICollidable)
{
var entityCollision = (entity as Math.Geometry.ICollidable).Collision;
entityCollision.Polygons.Add(polygon);
polygon.AttachTo(entity, false);
}
}
}
}
}
}
private static void CreateEntitiesFromCircles(LayeredTileMap layeredTileMap, ShapeCollection shapeCollection, InstantiationRestrictions restrictions)
{
var circles = shapeCollection.Circles;
for (int i = circles.Count - 1; i > -1; i--)
{
var circle = circles[i];
if (!string.IsNullOrEmpty(circle.Name) && layeredTileMap.ShapeProperties.ContainsKey(circle.Name))
{
var properties = layeredTileMap.ShapeProperties[circle.Name];
var entityAddingProperty = properties.FirstOrDefault(item => item.Name == "EntityToCreate" || item.Name == "Type");
var entityType = entityAddingProperty.Value as string;
var shouldCreate = !string.IsNullOrEmpty(entityType);
if (restrictions?.InclusiveList != null)
{
shouldCreate = restrictions.InclusiveList.Contains(entityType);
}
if (shouldCreate)
{
PositionedObject entity = CreateEntity(entityType);
if (entity != null)
{
entity.Name = circle.Name;
ApplyPropertiesTo(entity, properties, circle.Position);
if (CurrentSettings.RemoveTileObjectsAfterEntityCreation)
{
shapeCollection.Circles.Remove(circle);
}
if (entity is Math.Geometry.ICollidable)
{
var entityCollision = (entity as Math.Geometry.ICollidable).Collision;
entityCollision.Circles.Add(circle);
circle.AttachTo(entity, false);
}
}
}
}
}
}
private void LoadLevel(string levelNameToLoad)
{
TMXGlueLib.DataTypes.ReducedTileMapInfo.FastCreateFromTmx = true;
currentLevel = (LayeredTileMap)GetFile(levelNameToLoad);
currentLevel.AddToManagers(WorldLayer);
TileEntityInstantiator.CreateEntitiesFrom(currentLevel);
#if DEBUG
ApplyDebugInitializationValues();
#endif
foreach (var item in SafeZoneList)
{
item.SetupCollision();
}
}
/// <summary>
/// Load a navmesh from Tiled and switch it to be the current navmesh.
/// Currently assumes that the polygons are squares!
/// </summary>
/// <param name="tilemap">The tilemap that contains polygons under an object layer</param>
/// <param name="objectLayerName">The name of the object layer in the tilemap</param>
/// <param name="meshShrinkAmount">The amount (in pixels) that the navmesh has been
/// shrunk around obstacles (a.k.a the amount obstacles have been expanded)</param>
/// <returns></returns>
public static NavMesh <TNode, TLink> BuildNavMeshFromTiled <TNode, TLink>(LayeredTileMap tilemap, string objectLayerName /*, int meshShrinkAmount = 0*/)
where TNode : PortalNodeBase <TLink, TNode>, new()
where TLink : LinkBase <TLink, TNode>, new()
{
// Load up the object layer
ShapeCollection objectLayer = tilemap.ShapeCollections.FirstOrDefault(layer => layer.Name == objectLayerName);
if (objectLayer == null)
{
throw new Exception($"NavMeshPlugin: The given tilemap has no object layer with the name \"{objectLayerName}\"");
}
else if (objectLayer.AxisAlignedRectangles.Count == 0)
{
throw new Exception($"NavMeshPlugin: The \"{objectLayerName}\" object layer in the Tilemap has 0 objects in it");
}
// Build the navmesh
// R: FRB version v1 - not sure if right - vertices order may be important
return(new NavMesh <TNode, TLink>(objectLayer.AxisAlignedRectangles));
}
private static TileNodeNetwork CreateTileNodeNetwork(LayeredTileMap layeredTileMap, DirectionalType directionalType)
{
var numberOfTilesWide =
MathFunctions.RoundToInt(layeredTileMap.Width / layeredTileMap.WidthPerTile.Value);
var numberOfTilesTall =
MathFunctions.RoundToInt(layeredTileMap.Height / layeredTileMap.HeightPerTile.Value);
var tileWidth = layeredTileMap.WidthPerTile.Value;
var dimensionHalf = tileWidth / 2.0f;
TileNodeNetwork nodeNetwork = new TileNodeNetwork(
0 + dimensionHalf,
-layeredTileMap.Height + tileWidth / 2.0f,
tileWidth,
numberOfTilesWide,
numberOfTilesTall,
directionalType);
return(nodeNetwork);
}
public static TileNodeNetwork CreateFromTilesWithProperties(LayeredTileMap layeredTileMap, DirectionalType directionalType,
ICollection <string> types)
{
Func <List <TMXGlueLib.DataTypes.NamedValue>, bool> predicate = (list) =>
{
var toReturn = false;
foreach (var namedValue in list)
{
if (types.Contains(namedValue.Name))
{
toReturn = true;
break;
}
}
return(toReturn);
};
return(CreateFrom(layeredTileMap, directionalType, predicate));
}
public static void CreateEntitiesFrom(LayeredTileMap layeredTileMap)
{
var entitiesToRemove = new List <string>();
foreach (var layer in layeredTileMap.MapLayers)
{
CreateEntitiesFrom(entitiesToRemove, layer, layeredTileMap.TileProperties);
}
foreach (var entityToRemove in entitiesToRemove)
{
string remove = entityToRemove;
layeredTileMap.RemoveTiles(t => t.Any(item => (item.Name == "EntityToCreate" || item.Name == "Type") && item.Value as string == remove), layeredTileMap.TileProperties);
}
foreach (var shapeCollection in layeredTileMap.ShapeCollections)
{
CreateEntitiesFromCircles(layeredTileMap, shapeCollection);
CreateEntitiesFromRectangles(layeredTileMap, shapeCollection);
CreateEntitiesFromPolygons(layeredTileMap, shapeCollection);
}
}
// This was not originally public but made public for situations where users want to
// manually specify which tiles to use rather than relying on the HasCollision methods.
public static void AddCollisionFrom(this TileShapeCollection tileShapeCollection,
LayeredTileMap layeredTileMap, IEnumerable <string> namesToUse)
{
// prob need to clear out the tileShapeCollection
float dimension = float.NaN;
float dimensionHalf = 0;
foreach (var layer in layeredTileMap.MapLayers)
{
var dictionary = layer.NamedTileOrderedIndexes;
foreach (var name in namesToUse)
{
if (dictionary.ContainsKey(name))
{
var indexList = dictionary[name];
foreach (var index in indexList)
{
float left;
float bottom;
layer.GetBottomLeftWorldCoordinateForOrderedTile(index, out left, out bottom);
if (float.IsNaN(dimension))
{
dimension = layer.Vertices[(index * 4) + 1].Position.X - left;
dimensionHalf = dimension / 2.0f;
tileShapeCollection.GridSize = dimension;
}
tileShapeCollection.AddCollisionAtWorld(left + dimensionHalf,
bottom + dimensionHalf);
}
}
}
}
}
public Stage(LayeredTileMap map)
{
sCollision = new TileShapeCollection();
cCollision = new TileShapeCollection();
var tilesWithCollision = map.TileProperties
.Where(item => item.Value.Any(property => property.Name == "HasCollision" && String.Equals((string)property.Value, "true", StringComparison.OrdinalIgnoreCase)))
.Where(item => item.Value.Any(property => property.Name == "Is Cloud" && !String.Equals((string)property.Value, "true", StringComparison.OrdinalIgnoreCase) ||
item.Value.All(property2 => property2.Name != "Is Cloud")))
.Select(item => item.Key).ToList();
var tilesWithCloudCollision = map.TileProperties
.Where(item => item.Value.Any(property => property.Name == "HasCollision" && String.Equals((string)property.Value, "true", StringComparison.OrdinalIgnoreCase)))
.Where(item => item.Value.Any(property => property.Name == "Is Cloud" && String.Equals((string)property.Value, "true", StringComparison.OrdinalIgnoreCase)))
.Select(item => item.Key).ToList();
sCollision.AddCollisionFrom(map, tilesWithCollision);
cCollision.AddCollisionFrom(map, tilesWithCloudCollision);
sCollision.Visible = false;
cCollision.Visible = false;
}
public static void FillFromPredicate(this TileNodeNetwork nodeNetwork, LayeredTileMap layeredTileMap, Func <List <NamedValue>, bool> predicate)
{
var dimensionHalf = layeredTileMap.WidthPerTile.Value / 2.0f;
var properties = layeredTileMap.TileProperties;
foreach (var kvp in properties)
{
string name = kvp.Key;
var namedValues = kvp.Value;
if (predicate(namedValues))
{
foreach (var layer in layeredTileMap.MapLayers)
{
var dictionary = layer.NamedTileOrderedIndexes;
if (dictionary.ContainsKey(name))
{
var indexList = dictionary[name];
foreach (var index in indexList)
{
float left;
float bottom;
layer.GetBottomLeftWorldCoordinateForOrderedTile(index, out left, out bottom);
var centerX = left + dimensionHalf;
var centerY = bottom + dimensionHalf;
nodeNetwork.AddAndLinkTiledNodeWorld(centerX, centerY);
}
}
}
}
}
}
private static void AddNodes(LayeredTileMap map, string layerName, NodeType tileProperty, ref TileNodeNetwork network, int gridWidth)
{
var layer = map.MapLayers.FirstOrDefault(l => l.Name.Equals(layerName));
var tileNamesForPath = map.TileProperties
.Where(item => item.Value
.Any(customProperty => customProperty.Value.Equals(tileProperty.ToString())))
.Select(item => item.Key)
.ToArray();
foreach (var tileName in tileNamesForPath)
{
var indexes = layer != null && layer.NamedTileOrderedIndexes.ContainsKey(tileName)
? layer.NamedTileOrderedIndexes[tileName]
: null;
if (indexes == null)
{
continue;
}
for (var i = indexes.Count - 1; i > -1; i--)
{
var gridIncrement = map.WidthPerTile / gridWidth;
layer.GetBottomLeftWorldCoordinateForOrderedTile(indexes[i], out float x, out float y);
for (var j = 0; j < gridIncrement; j++)
{
for (var k = 0; k < gridIncrement; k++)
{
var node = network.AddAndLinkTiledNodeWorld(x + (gridWidth * j), y + (gridWidth * k));
node.PropertyField = (1 << (int)(tileProperty));
}
}
}
}
}
public static void AddCollisionFrom(this TileShapeCollection tileShapeCollection,
MapDrawableBatch layer, LayeredTileMap layeredTileMap, Func <List <TMXGlueLib.DataTypes.NamedValue>, bool> predicate)
{
var properties = layeredTileMap.TileProperties;
foreach (var kvp in properties)
{
string name = kvp.Key;
var namedValues = kvp.Value;
if (predicate(namedValues))
{
float dimension = layeredTileMap.WidthPerTile.Value;
float dimensionHalf = dimension / 2.0f;
tileShapeCollection.GridSize = dimension;
var dictionary = layer.NamedTileOrderedIndexes;
if (dictionary.ContainsKey(name))
{
var indexList = dictionary[name];
foreach (var index in indexList)
{
float left;
float bottom;
layer.GetBottomLeftWorldCoordinateForOrderedTile(index, out left, out bottom);
var centerX = left + dimensionHalf;
var centerY = bottom + dimensionHalf;
tileShapeCollection.AddCollisionAtWorld(centerX,
centerY);
}
}
}
}
}
public static TileNodeNetwork CreateFromTiledMap(LayeredTileMap map)
{
var costs = new float[32];
costs[(int)NodeType.Normal] = 2;
costs[(int)NodeType.Path] = 1;
const int gridWidth = 64;
var network = new TileNodeNetwork(0, //GridWidth / 2f,
-map.Height, // + GridWidth / 2f,
gridWidth,
MathFunctions.RoundToInt(map.Width / gridWidth),
MathFunctions.RoundToInt(map.Height / gridWidth),
DirectionalType.Eight);
AddNodes(map, "Ground", NodeType.Normal, ref network, gridWidth);
AddNodes(map, "Ground", NodeType.Path, ref network, gridWidth);
network.SetCosts(costs);
return(network);
}
public static void CreateEntitiesFrom(LayeredTileMap layeredTileMap, Dictionary<string, TileMapInfo> tileMapInfos)
{
IEnumerable<TileMapInfo> tileMapInfoEnumerable = tileMapInfos.Values;
CreateEntitiesFrom(layeredTileMap, tileMapInfoEnumerable);
}
public static void AddMergedCollisionFromTilesWithProperty(this TileShapeCollection tileShapeCollection, LayeredTileMap layeredTileMap, string propertyName)
{
tileShapeCollection.AddMergedCollisionFrom(
layeredTileMap, (list) => list.Any(item => item.Name == propertyName));
}
public static void AddMergedCollisionFromTilesWithType(this TileShapeCollection tileShapeCollection, LayeredTileMap layeredTileMap, string type)
{
tileShapeCollection.AddMergedCollisionFrom(
layeredTileMap, (list) => list.Any(item => item.Name == "Type" && (item.Value as string) == type));
}
