public Polygon2D GetRoomTemplateOutline()
{
var tilemaps = RoomTemplateUtilsGrid2D.GetTilemaps(gameObject);
var outlineTilemaps = RoomTemplateUtilsGrid2D.GetTilemapsForOutline(tilemaps);
var usedTiles = RoomTemplateUtilsGrid2D.GetUsedTiles(outlineTilemaps);
if (usedTiles.Count == 0)
{
return(null);
}
var minX = usedTiles.Min(x => x.x);
var maxX = usedTiles.Max(x => x.x);
var minY = usedTiles.Min(x => x.y);
var maxY = usedTiles.Max(x => x.y) + PaddingTop;
var polygonPoints = new List <Vector2Int>()
{
new Vector2Int(minX, minY),
new Vector2Int(minX, maxY),
new Vector2Int(maxX, maxY),
new Vector2Int(maxX, minY),
};
return(new Polygon2D(polygonPoints));
}
public bool HasOutlineOverride()
{
var tilemapsRoot = RoomTemplateUtilsGrid2D.GetTilemapsRoot(gameObject);
var outlineOverride = tilemapsRoot.transform.Find(GeneratorConstantsGrid2D.OutlineOverrideLayerName);
return(outlineOverride != null);
}
internal static List <Tilemap> GetTilemaps(GameObject gameObject, Predicate <IgnoreTilemap> excludePredicate)
{
return(RoomTemplateUtilsGrid2D
.GetTilemaps(gameObject)
.Where(tilemap =>
{
var ignoreTilemap = tilemap.GetComponent <IgnoreTilemap>();
return ignoreTilemap == null || !excludePredicate(ignoreTilemap);
})
.ToList());
}
public void RemoveOutlineOverride()
{
if (!HasOutlineOverride())
{
return;
}
var tilemapsRoot = RoomTemplateUtilsGrid2D.GetTilemapsRoot(gameObject);
var outlineOverride = tilemapsRoot.transform.Find(GeneratorConstantsGrid2D.OutlineOverrideLayerName).gameObject;
PostProcessUtilsGrid2D.Destroy(outlineOverride);
}
/// <summary>
/// Sets a given material to all shared tilemap layers.
/// </summary>
/// <param name="level"></param>
/// <param name="tilemapMaterial"></param>
public static void SetTilemapsMaterial(GeneratedLevel level, Material tilemapMaterial)
{
if (tilemapMaterial == null)
{
return;
}
var tilemapsRoot = RoomTemplateUtilsGrid2D.GetTilemapsRoot(level.RootGameObject);
foreach (var tilemapRenderer in tilemapsRoot.GetComponentsInChildren <TilemapRenderer>())
{
tilemapRenderer.material = tilemapMaterial;
}
}
/// <summary>
/// Computes a polygon from points on given tilemaps.
/// </summary>
/// <param name="roomTemplate"></param>
/// <returns></returns>
public static PolygonGrid2D GetPolygonFromRoomTemplate(GameObject roomTemplate)
{
var outlineHandler = roomTemplate.GetComponent <IRoomTemplateOutlineHandlerGrid2D>();
if (outlineHandler != null)
{
var polygon2d = outlineHandler.GetRoomTemplateOutline();
return(polygon2d?.GetGridPolygon());
}
var tilemaps = RoomTemplateUtilsGrid2D.GetTilemaps(roomTemplate);
var outline = RoomTemplateUtilsGrid2D.GetTilemapsForOutline(tilemaps);
return(GetPolygonFromTilemaps(outline));
}
/// <summary>
/// Initializes shared tilemaps of a given level.
/// </summary>
/// <param name="level">Generated level.</param>
/// <param name="mode">Tilemap layers mode.</param>
/// <param name="defaultTilemapLayersHandler">Default tilemap layers handler. Used for the Default mode.</param>
/// <param name="customTilemapLayersHandler">Custom tilemap layers handler. Used for the Custom mode.</param>
/// <param name="example">Example game object for tilemaps structure. Used for the FromExample mode.</param>
public static void InitializeSharedTilemaps(GeneratedLevel level, TilemapLayersStructureModeGrid2D mode, ITilemapLayersHandlerGrid2D defaultTilemapLayersHandler, ITilemapLayersHandlerGrid2D customTilemapLayersHandler, GameObject example)
{
GameObject tilemapsRoot;
if (mode == TilemapLayersStructureModeGrid2D.FromExample)
{
if (example == null)
{
throw new ConfigurationException($"When {nameof(PostProcessingConfigGrid2D.TilemapLayersStructure)} is set to {nameof(TilemapLayersStructureModeGrid2D.FromExample)}, {nameof(PostProcessingConfigGrid2D.TilemapLayersExample)} must not be null. Please set the field in the Dungeon Generator component.");
}
var tilemapsSource = example;
var tilemapsSourceRoot = RoomTemplateUtilsGrid2D.GetTilemapsRoot(tilemapsSource);
if (tilemapsSourceRoot == tilemapsSource)
{
throw new ConfigurationException($"Given {nameof(PostProcessingConfigGrid2D.TilemapLayersExample)} is not valid as it does not contain a game object called {GeneratorConstantsGrid2D.TilemapsRootName} that holds individual tilemap layers.");
}
tilemapsRoot = Object.Instantiate(tilemapsSourceRoot, level.RootGameObject.transform);
tilemapsRoot.name = GeneratorConstantsGrid2D.TilemapsRootName;
foreach (var tilemap in tilemapsRoot.GetComponentsInChildren <Tilemap>())
{
tilemap.ClearAllTiles();
}
}
else
{
// Initialize GameObject that will hold tilemaps
tilemapsRoot = new GameObject(GeneratorConstantsGrid2D.TilemapsRootName);
tilemapsRoot.transform.parent = level.RootGameObject.transform;
if (mode == TilemapLayersStructureModeGrid2D.Default)
{
defaultTilemapLayersHandler.InitializeTilemaps(tilemapsRoot);
}
else if (mode == TilemapLayersStructureModeGrid2D.Custom)
{
if (customTilemapLayersHandler == null)
{
throw new ConfigurationException($"When {nameof(PostProcessingConfigGrid2D.TilemapLayersStructure)} is set to {nameof(TilemapLayersStructureModeGrid2D.Custom)}, {nameof(PostProcessingConfigGrid2D.TilemapLayersHandler)} must not be null. Please set the field in the Dungeon Generator component.");
}
customTilemapLayersHandler.InitializeTilemaps(tilemapsRoot);
}
}
}
public void AddOutlineOverride()
{
if (HasOutlineOverride())
{
return;
}
var tilemapsRoot = RoomTemplateUtilsGrid2D.GetTilemapsRoot(gameObject);
var outlineOverride = new GameObject(GeneratorConstantsGrid2D.OutlineOverrideLayerName);
outlineOverride.transform.parent = tilemapsRoot.transform;
outlineOverride.AddComponent <Tilemap>();
outlineOverride.AddComponent <TilemapRenderer>();
outlineOverride.AddComponent <OutlineOverrideGrid2D>();
outlineOverride.GetComponent <TilemapRenderer>().sortingOrder = 1000;
}
/// <summary>
/// Copies tiles from a given room template to given destination tilemaps.
/// </summary>
/// <remarks>
/// One important aspect of this method is how to handle already existing tiles in destination tilemaps.
///
/// When deleteNonNullTiles is true, it computes all non-null positions across all layers in the room template.
/// After that, it deletes all tiles on these positions in destination tilemaps.
///
/// When deleteTilesInsideOutline is true, it computes all tiles inside the outline of the room template and
/// deletes them from the destination tilemaps.
/// So even if there is a hole inside the room template, the position is still removed.
///
/// deleteNonNullTiles and deleteTilesInsideOutline can be combined together.
/// </remarks>
/// <param name="roomInstance">Room instance to be copied to the destination tilemaps.</param>
/// <param name="destinationTilemaps">List of destination tilemaps.</param>
/// <param name="deleteNonNullTiles">Whether to delete non-null tiles from destination tilemaps.</param>
/// <param name="deleteTilesInsideOutline">Whether to delete all tiles insides the outline from destination tilemaps.</param>
public static void CopyTiles(RoomInstance roomInstance, List <Tilemap> destinationTilemaps, bool deleteNonNullTiles, bool deleteTilesInsideOutline)
{
var sourceTilemaps = RoomTemplateUtilsGrid2D.GetTilemaps(roomInstance.RoomTemplateInstance);
sourceTilemaps = RoomTemplateUtilsGrid2D.GetTilemapsForCopying(sourceTilemaps);
var tilesToRemove = new List <Vector3Int>();
if (deleteNonNullTiles)
{
var tiles = GetNonNullTiles(sourceTilemaps);
tilesToRemove.AddRange(tiles.Select(x => x + roomInstance.Position));
}
if (deleteTilesInsideOutline)
{
var tiles = GetTilesInsideOutline(roomInstance, false);
tilesToRemove.AddRange(tiles);
}
RemoveTiles(destinationTilemaps, tilesToRemove);
foreach (var sourceTilemap in sourceTilemaps)
{
var destinationTilemap = destinationTilemaps.FirstOrDefault(x => x.name == sourceTilemap.name);
if (destinationTilemap == null)
{
continue;
}
foreach (var tilemapPosition in sourceTilemap.cellBounds.allPositionsWithin)
{
var tile = sourceTilemap.GetTile(tilemapPosition);
if (tile != null)
{
destinationTilemap.SetTile(tilemapPosition + roomInstance.Position, tile);
destinationTilemap.SetTransformMatrix(tilemapPosition + roomInstance.Position, sourceTilemap.GetTransformMatrix(tilemapPosition));
}
}
}
}
/// <summary>
/// Gets all tiles that are not null in given tilemaps.
/// </summary>
/// <param name="tilemaps"></param>
/// <returns></returns>
public static HashSet <Vector2Int> GetUsedTiles(IEnumerable <Tilemap> tilemaps)
{
return(RoomTemplateUtilsGrid2D.GetUsedTiles(tilemaps));
}
/// <summary>
/// Gets tilemaps that should be used when computing room template outline.
/// </summary>
/// <param name="tilemaps"></param>
/// <returns></returns>
public static List <Tilemap> GetTilemapsForOutline(ICollection <Tilemap> tilemaps)
{
return(RoomTemplateUtilsGrid2D.GetTilemapsForOutline(tilemaps));
}
/// <summary>
/// Gets all the tilemap layers from the room template GameObject.
/// </summary>
/// <remarks>
/// Only tilemaps that are direct children of the tilemap root GameObject are returned.
/// That means that if there is a tilemap that is not a direct child of the tilemaps root
/// (e.g. it is part of a prefab that should be instantiated alongside the room template),
/// it is not returned here and is not used to compute room template outlines.
/// </remarks>
/// <param name="roomTemplate">GameObject representing the room template.</param>
/// <param name="includeInactive">Whether inactive tilemaps should be returned.</param>
/// <returns></returns>
public static List <Tilemap> GetTilemaps(GameObject roomTemplate, bool includeInactive = true)
{
return(RoomTemplateUtilsGrid2D.GetTilemaps(roomTemplate, includeInactive));
}
/// <summary>
/// Gets the GameObject that is the parent to all the tilemaps.
/// </summary>
/// <remarks>
/// If there is no child named GeneratorConstants.TilemapsRootName, the room template GameObject
/// itself is returned to provide backwards compatibility.
/// </remarks>
/// <param name="roomTemplate">GameObject representing the room template.</param>
/// <returns></returns>
public static GameObject GetTilemapsRoot(GameObject roomTemplate)
{
return(RoomTemplateUtilsGrid2D.GetTilemapsRoot(roomTemplate));
}
/// <summary>
/// Computes a polygon from points on given tilemaps.
/// </summary>
/// <param name="tilemaps"></param>
/// <returns></returns>
public static PolygonGrid2D GetPolygonFromTilemaps(ICollection <Tilemap> tilemaps)
{
var usedTiles = GetUsedTiles(RoomTemplateUtilsGrid2D.GetTilemapsForOutline(tilemaps));
return(GetPolygonFromTiles(usedTiles));
}
/// <summary>
/// Gets all the shared tilemaps.
/// </summary>
/// <returns></returns>
public List <Tilemap> GetSharedTilemaps()
{
return(RoomTemplateUtilsGrid2D.GetTilemaps(RootGameObject));
}