private static void BuildIntGridLayer(LDtkDataLayer layer, LDtkIntGridValueAssetCollection intGridValueAssets,
Grid tilemapPrefab)
{
if (IsAssetNull(intGridValueAssets))
{
return;
}
if (IsAssetNull(tilemapPrefab))
{
return;
}
DecrementLayer();
Tilemap tilemap = LDtkUnityTilesetBuilder.BuildUnityTileset(layer.__identifier, tilemapPrefab, _layerSortingOrder);
if (tilemap == null)
{
return;
}
LDtkBuilderIntGridValue.BuildIntGridValues(layer, intGridValueAssets, tilemap);
LDtkUnityTilesetBuilder.SetTilesetOpacity(tilemap, layer.__opacity);
}
public static void BuildTileset(LDtkDataLayer layer, LDtkDataTile[] tiles, LDtkTilesetAssetCollection assets, Tilemap[] tilemaps)
{
LDtkDefinitionTileset definition = layer.IsAutoTilesLayer
? layer.Definition.AutoTilesetDefinition
: layer.Definition.TileLayerDefinition;
LDtkTilesetAsset asset = assets.GetAssetByIdentifier(definition.identifier);
if (asset == null)
{
return;
}
//figure out if we have already built a tile in this position. otherwise, build up to the next tilemap
Dictionary <Vector2Int, int> builtTileLayering = new Dictionary <Vector2Int, int>();
foreach (LDtkDataTile tileData in tiles)
{
Vector2Int px = tileData.px.ToVector2Int();
int tilemapLayer = GetTilemapLayerToBuildOn(builtTileLayering, px, tilemaps.Length - 1);
BuildTile(layer, tileData, asset, tilemaps[tilemapLayer]);
}
}
private static void BuildTilesetLayer(LDtkDataLayer layer, LDtkDataTile[] tiles,
LDtkTilesetAssetCollection tilesetAssets, Grid tilemapPrefab)
{
if (IsAssetNull(tilesetAssets))
{
return;
}
var grouped = tiles.Select(p => p.px.ToVector2Int()).ToLookup(x => x);
int maxRepetitions = grouped.Max(x => x.Count());
string objName = layer.__identifier;
if (layer.IsIntGridLayer)
{
objName += "_AutoLayer";
}
//this is for the potential of having multiple rules apply to the same tile. make multiple Unity Tilemaps.
Tilemap[] tilemaps = new Tilemap[maxRepetitions];
for (int i = 0; i < maxRepetitions; i++)
{
string name = objName;
name += $"_{i}";
Tilemap tilemap = BuildUnityTileset(name, tilemapPrefab);
if (tilemap == null)
{
return;
}
tilemaps[i] = tilemap;
}
LDtkBuilderTileset.BuildTileset(layer, tiles, tilesetAssets, tilemaps);
}
public static void BuildIntGridValues(LDtkDataLayer layer, LDtkIntGridValueAssetCollection valueAssets, Tilemap tilemap)
{
foreach (LDtkDataIntGridValue intTile in layer.intGrid)
{
BuildIntGridValue(layer, intTile, valueAssets, tilemap);
}
TryTurnOffRenderer(valueAssets, tilemap);
}
private static void BuildEntityInstanceLayer(LDtkDataLayer layer, LDtkEntityAssetCollection entityAssets)
{
if (IsAssetNull(entityAssets))
{
return;
}
DecrementLayer();
LDtkBuilderEntityInstance.BuildEntityLayerInstances(layer, entityAssets, _layerSortingOrder);
}
public static void BuildEntityLayerInstances(LDtkDataLayer layerData, LDtkEntityAssetCollection entityAssets,
int layerSortingOrder)
{
LDtkParsedPoint.InformOfRecentLayerVerticalCellCount(layerData.__cHei);
GameObject layerObj = new GameObject(layerData.__identifier);
foreach (LDtkDataEntity entityData in layerData.entityInstances)
{
BuildEntityInstance(layerData, entityData, entityAssets, layerObj, layerSortingOrder);
}
}
public void GetLevelBounds()
{
const string lvlName = "Level";
TextAsset jsonProject = TestJsonLoader.LoadGenericProject();
LDtkDataProject project = LDtkToolProjectLoader.LoadProject(jsonProject.text);
LDtkDataLevel level = project.levels.FirstOrDefault(p => p.identifier == lvlName);
LDtkDataLayer layer = level.layerInstances.FirstOrDefault(p => p.IsIntGridLayer);
Bounds bounds = layer.LayerUnitBounds;
Debug.Log(bounds);
}
private static void BuildTilesetLayer(LDtkDataLayer layer, LDtkDataTile[] tiles,
LDtkTilesetAssetCollection tilesetAssets, Grid tilemapPrefab)
{
if (IsAssetNull(tilesetAssets))
{
return;
}
if (IsAssetNull(tilemapPrefab))
{
return;
}
var grouped = tiles.Select(p => p.px.ToVector2Int()).ToLookup(x => x);
int maxRepetitions = grouped.Max(x => x.Count());
string gameObjectName = layer.__identifier;
if (layer.IsIntGridLayer)
{
gameObjectName += "_AutoLayer";
}
//this is for the potential of having multiple rules apply to the same tile. make multiple Unity Tilemaps.
Tilemap[] tilemaps = new Tilemap[maxRepetitions];
for (int i = 0; i < maxRepetitions; i++)
{
DecrementLayer();
string name = gameObjectName;
name += $"_{i}";
Tilemap tilemap = LDtkUnityTilesetBuilder.BuildUnityTileset(name, tilemapPrefab, _layerSortingOrder);
if (tilemap == null)
{
return;
}
tilemaps[i] = tilemap;
}
LDtkBuilderTileset.BuildTileset(layer, tiles, tilesetAssets, tilemaps);
//set each layer's alpha
foreach (Tilemap tilemap in tilemaps)
{
LDtkUnityTilesetBuilder.SetTilesetOpacity(tilemap, layer.__opacity);
}
}
private static void BuildEntityInstance(LDtkDataLayer layerData, LDtkDataEntity entityData,
LDtkEntityAssetCollection entityAssets, GameObject layerObj, int layerSortingOrder)
{
LDtkEntityAsset entityAsset = entityAssets.GetAssetByIdentifier(entityData.__identifier);
if (entityAsset == null)
{
return;
}
int pixelsPerUnit = layerData.__gridSize;
Vector2Int pixelPos = entityData.px.ToVector2Int();
Vector2 spawnPos = (LDtkToolOriginCoordConverter.ConvertPosition(pixelPos, layerData.__cHei * pixelsPerUnit, pixelsPerUnit) / pixelsPerUnit) + Vector2.up;
InstantiateEntity(entityData, entityAsset.ReferencedAsset, spawnPos, layerObj, layerSortingOrder);
}
private static void BuildLayerInstance(LDtkDataLayer layer, LDtkProjectAssets assets)
{
if (layer.IsIntGridLayer)
{
BuildIntGridLayer(layer, assets.CollisionValues, assets.TilemapPrefab);
}
if (layer.IsAutoTilesLayer)
{
BuildTilesetLayer(layer, layer.autoLayerTiles, assets.Tilesets, assets.TilemapPrefab);
}
if (layer.IsGridTilesLayer)
{
BuildTilesetLayer(layer, layer.gridTiles, assets.Tilesets, assets.TilemapPrefab);
}
if (layer.IsEntityInstancesLayer)
{
BuildEntityInstanceLayer(layer, assets.EntityInstances);
}
}
private static void BuildIntGridValue(LDtkDataLayer layer, LDtkDataIntGridValue intValueData, LDtkIntGridValueAssetCollection valueAssets, Tilemap tilemap)
{
LDtkDefinitionIntGridValue definition = layer.Definition.intGridValues[intValueData.v];
LDtkIntGridValueAsset asset = valueAssets.GetAssetByIdentifier(definition.identifier);
if (asset == null)
{
return;
}
Vector2Int cellCoord = LDtkToolOriginCoordConverter.GetTopLeftOriginCellCoordFromCoordID(intValueData.coordId, layer.__cWid);
Vector2 coord = LDtkToolOriginCoordConverter.ConvertCell(cellCoord, layer.__cHei);
Tile tileAsset = LDtkProviderTile.GetTile(asset, definition.color.ToColor());
Vector3Int c = new Vector3Int((int)coord.x, (int)coord.y, 0);
tilemap.SetTile(c, tileAsset);
}
private static void BuildIntGridLayer(LDtkDataLayer layer, LDtkIntGridValueAssetCollection intGridValueAssets,
Grid tilemapPrefab)
{
if (IsAssetNull(intGridValueAssets))
{
return;
}
string objName = layer.__identifier;
Tilemap tilemap = BuildUnityTileset(objName, tilemapPrefab);
if (tilemap == null)
{
return;
}
LDtkBuilderIntGridValue.BuildIntGridValues(layer, intGridValueAssets, tilemap);
}
private static void BuildTile(LDtkDataLayer layer, LDtkDataTile tileData, LDtkTilesetAsset asset, Tilemap tilemap)
{
Vector2Int coord = tileData.LayerPixelPosition / layer.__gridSize;
coord = LDtkToolOriginCoordConverter.ConvertCell(coord, layer.__cHei);
Sprite tileSprite = GetTileFromTileset(asset.ReferencedAsset, tileData.SourcePixelPosition, layer.__gridSize);
Tile tile = ScriptableObject.CreateInstance <Tile>();
tile.colliderType = Tile.ColliderType.None;
tile.sprite = tileSprite;
Vector3Int co = new Vector3Int(coord.x, coord.y, 0);
//Tilemap mapToBuildOn = tilemap;
tilemap.SetTile(co, tile);
SetTileFlips(tilemap, tileData, coord);
}
private static void BuildEntityInstance(LDtkDataLayer layerData, LDtkDataEntity entityData,
LDtkEntityAssetCollection entityAssets, GameObject layerObj, int layerSortingOrder)
{
LDtkEntityAsset entityAsset = entityAssets.GetAssetByIdentifier(entityData.__identifier);
if (entityAsset == null)
{
return;
}
int pixelsPerUnit = layerData.__gridSize;
Vector2Int pixelPos = entityData.px.ToVector2Int();
Vector2 spawnPos = (LDtkToolOriginCoordConverter.ConvertPosition(pixelPos, layerData.__cHei * pixelsPerUnit, pixelsPerUnit) / pixelsPerUnit) + Vector2.up;
GameObject entityObj = InstantiateEntity(entityAsset.ReferencedAsset, spawnPos, layerObj);
LDtkFieldInjector.InjectInstanceFields(entityData, entityObj);
MonoBehaviour[] behaviors = entityObj.GetComponents <MonoBehaviour>();
PostEntityInterfaceEvent <ILDtkFieldInjectedEvent>(behaviors, e => e.OnLDtkFieldsInjected());
PostEntityInterfaceEvent <ILDtkSettableSortingOrder>(behaviors, e => e.OnLDtkSetSortingOrder(layerSortingOrder));
PostEntityInterfaceEvent <ILDtkSettableOpacity>(behaviors, e => e.OnLDtkSetOpacity(layerData.__opacity));
}
