public World Resolve()
{
_tilemapGround = tilemapGround.Resolve();
_tilemapStructures = tilemapStructures.Resolve();
_tilemapUnits = tilemapUnits.Resolve();
return(this);
}
/// <summary>
/// Serializes rooms.
/// </summary>
/// <param name="tilemaps">Tilemaps from a single room. They should be ordered from bottom to top in layers.</param>
/// <param name="FileName">Name of the serialized data file that will be saved.</param>
public void SerializeRoom(Tilemap[] tilemaps, int[] layerNumbers, String FileName)
{
FileName = "PremadeRooms/" + FileName;
List <TilemapWrapper> tilemapWrappers = new List <TilemapWrapper>();
_stream = File.Open(Path.Combine(Application.dataPath, FileName), FileMode.OpenOrCreate);
Vector3Int[] positions = new Vector3Int[tilemaps.Length];
// HARDCODED TO 0.5, because unity treats it as half, it will always be half
Vector2 halfPivot = new Vector2(0.5f, 0.5f);
TilemapWrapper?tilemapFlag = null;
int sizeOfTilemaps = 0;
int iterator = 0;
foreach (Tilemap tilemap in tilemaps)
{
tilemap.CompressBounds();
List <SerializableVector3Int> tilePositionsInTilemap = new List <SerializableVector3Int>();
List <string> namesInTilemap = new List <string>();
List <float> xmins = new List <float>();
List <float> ymins = new List <float>();
List <float> widths = new List <float>();
List <float> heights = new List <float>();
float pixelsPerUnit = 0;
int layerNumber = layerNumbers[iterator];
foreach (Vector3Int tilePosition in tilemap.cellBounds.allPositionsWithin)
{
if (tilemap.GetTile(tilePosition) != null)
{
tilePositionsInTilemap.Add(tilePosition);
Sprite sprite = tilemap.GetSprite(tilePosition);
namesInTilemap.Add(sprite.texture.name);
var rect = sprite.rect;
xmins.Add(rect.xMin);
ymins.Add(rect.yMin);
widths.Add(rect.width);
heights.Add(rect.height);
pixelsPerUnit = sprite.pixelsPerUnit;
}
}
if (tilemap.gameObject.tag == "Flag")
{
tilemapFlag = new TilemapWrapper(tilePositionsInTilemap.ToArray(),
namesInTilemap.ToArray(), xmins.ToArray(), ymins.ToArray(), widths.ToArray(),
heights.ToArray(), halfPivot, pixelsPerUnit, layerNumber);
}
else
{
tilemapWrappers.Add(new TilemapWrapper(tilePositionsInTilemap.ToArray(),
namesInTilemap.ToArray(), xmins.ToArray(), ymins.ToArray(), widths.ToArray(),
heights.ToArray(), halfPivot, pixelsPerUnit, layerNumber));
}
iterator++;
}
// if we didnt manage to find the tileflag throw a warning
if (tilemapFlag != null)
{
RoomWrapper roomWrapper = new RoomWrapper(tilemapWrappers.ToArray(), tilemapFlag.Value);
_formatter.Serialize(_stream, roomWrapper);
}
else
{
Debug.LogError("No tilemap flag was added, make sure this is intentional." +
"Object: " + FileName);
}
_stream.Close();
}
public RoomWrapper(TilemapWrapper[] tilemapLayers, TilemapWrapper tilemapFlag)
{
this.tilemapLayers = tilemapLayers;
this.tilemapFlag = tilemapFlag;
}
public GameObject DeserializeAndCreateRoom(String FileName)
{
GameObject gridObject = GameObject.FindWithTag("Grid");
FileName = "PremadeRooms/" + FileName;
_stream = File.Open(Path.Combine(Application.dataPath, FileName), FileMode.Open);
RoomWrapper roomWrapper = (RoomWrapper)_formatter.Deserialize(_stream);
TilemapWrapper[] tilemapWrappers = roomWrapper.tilemapLayers;
TilemapWrapper? tilemapFlag = roomWrapper.tilemapFlag;
GameObject roomObject = new GameObject(FileName);
roomObject.transform.SetParent(gridObject.transform);
int layerIndexer = 0;
foreach (var tilemapWrapper in tilemapWrappers)
{
GameObject layerObject = new GameObject(layerIndexer.ToString());
layerObject.transform.SetParent(roomObject.transform);
Tilemap objectTilemap = layerObject.AddComponent <Tilemap>();
layerObject.AddComponent <TilemapRenderer>().sortingOrder = tilemapWrappers[layerIndexer].layerNumber;
int tileIndexer = 0;
Tile[] singleLayerTiles = new Tile[tilemapWrapper.tilePositions.Length];
foreach (var tilePosition in tilemapWrapper.tilePositions)
{
Rect rect = new Rect(tilemapWrapper.m_XMins[tileIndexer], tilemapWrapper.m_YMins[tileIndexer],
tilemapWrapper.m_Widths[tileIndexer], tilemapWrapper.m_Heights[tileIndexer]);
Tile createdTile = ScriptableObject.CreateInstance <Tile>();
Texture2D texture2D = Resources.Load <Texture2D>(tilemapWrapper.textureNames[tileIndexer]);
Sprite recreatedSprite = Sprite.Create(texture2D, rect,
tilemapWrapper.pivot, tilemapWrapper.pixelPerUnit);
createdTile.sprite = recreatedSprite;
objectTilemap.SetTile(tilePosition, createdTile);
tileIndexer++;
}
layerIndexer++;
}
// we deal with the flagtile differently
if (tilemapFlag != null)
{
//we know the flag is there so we get rid of the nullable
TilemapWrapper tilemapFlagValue = tilemapFlag.Value;
GameObject layerObject = new GameObject(layerIndexer.ToString());
layerObject.transform.SetParent(roomObject.transform);
Tilemap objectTilemap = layerObject.AddComponent <Tilemap>();
//just for debugging
layerObject.AddComponent <TilemapRenderer>().enabled = false;
layerObject.tag = "Flag";
int tileIndexer = 0;
Tile[] singleLayerTiles = new Tile[tilemapFlagValue.tilePositions.Length];
foreach (var tilePosition in tilemapFlagValue.tilePositions)
{
Rect rect = new Rect(tilemapFlagValue.m_XMins[tileIndexer], tilemapFlagValue.m_YMins[tileIndexer],
tilemapFlagValue.m_Widths[tileIndexer], tilemapFlagValue.m_Heights[tileIndexer]);
Tile createdTile = ScriptableObject.CreateInstance <Tile>();
Texture2D texture2D = Resources.Load <Texture2D>(tilemapFlagValue.textureNames[tileIndexer]);
Sprite recreatedSprite = Sprite.Create(texture2D, rect,
tilemapFlagValue.pivot, tilemapFlagValue.pixelPerUnit);
createdTile.sprite = recreatedSprite;
objectTilemap.SetTile(tilePosition, createdTile);
tileIndexer++;
}
}
_stream.Close();
return(roomObject);
}
internal void SetTilemapUnits(TilemapWrapper units)
{
_tilemapUnits = units;
}
public void SetTilemapStructures(TilemapWrapper structures)
{
_tilemapStructures = structures;
}
public void SetTilemapGround(TilemapWrapper ground)
{
_tilemapGround = ground;
}
public void Create(TilemapWrapper tilemap, UnityEngine.Tilemaps.TileBase[] tiles)
{
int width = 120;
int height = 60;
var back = new UnityEngine.Tilemaps.TileBase[height, width];
var fore = new UnityEngine.Tilemaps.TileBase[height, width];
for (int y = 0; y < height; ++y)
{
for (int x = 0; x < width; ++x)
{
fore[y, x] = back[y, x] = tiles[Random.Range(0, tiles.Length)];
}
}
{
int[] counts = new int[tiles.Length];
for (int i = 0; i < 3; ++i)
{
for (int y = 0; y < height; ++y)
{
for (int x = 0; x < width; ++x)
{
int highestCount = -1;
int highestCountIndex = -1;
for (int tilesIndex = 0; tilesIndex < tiles.Length; ++tilesIndex)
{
counts[tilesIndex] = 0;
}
for (int yscan = -1; yscan <= 1; ++yscan)
{
int ycheck = y + yscan;
if (ycheck < 0)
{
continue;
}
if (ycheck >= height)
{
break;
}
for (int xscan = -1; xscan <= 1; ++xscan)
{
int xcheck = x + xscan;
if (xcheck < 0 ||
(xcheck == 0 && ycheck == 0))
{
continue;
}
if (xcheck >= width)
{
break;
}
for (int tilesIndex = 0; tilesIndex < tiles.Length; ++tilesIndex)
{
if (tiles[tilesIndex] == fore[ycheck, xcheck])
{
counts[tilesIndex] += 1;
}
}
}
}
for (int tilesIndex = 0; tilesIndex < tiles.Length; ++tilesIndex)
{
if (counts[tilesIndex] > highestCount)
{
highestCount = counts[tilesIndex];
highestCountIndex = tilesIndex;
}
}
back[y, x] = tiles[highestCountIndex];
}
}
{ var temp = back; back = fore; fore = temp; }
}
}
for (int y = 0; y < height; ++y)
{
for (int x = 0; x < width; ++x)
{
tilemap.SetTile(new Vector2Int(x, y), fore[y, x]);
}
}
}
