public void Save()
{
var st = new TileMapSaveData();
st.sizeX = sizeX;
st.sizeY = sizeY;
st.tiles = new TileSaveData[sizeX + sizeY * sizeX];
UnityEngine.Debug.Log(sizeX + sizeY * sizeX);
UnityEngine.Debug.Log(st.tiles.Length);
int cx = 0;
int cy = 0;
LevelTileData tile = null;
for (int x = 0; x < sizeX; x++)
{
for (int y = 0; y < sizeY; y++)
{
cx = PosToChunk(x, y).x;
cy = PosToChunk(x, y).y;
tile = GetTileMap(cx, cy).GetTile(PosToPosInChunk(x, y).x, PosToPosInChunk(x, y).y).data;
st.tiles[x + y * sizeX] = new TileSaveData(tile);
}
}
XmlSerializer serializer = new XmlSerializer(typeof(TileMapSaveData));
FileStream stream = new FileStream(saveUtility.GetPath(), FileMode.Create);
serializer.Serialize(stream, st);
stream.Close();
}
public TileSaveData(LevelTileData data)
{
if (data == null)
{
return;
}
tileDataName = data.name;
}
public Node(LevelTileData _tileData, Vector3 _worldPos, int _gridX, int _gridY, int _penalty)
{
tileData = _tileData;
worldPosition = _worldPos;
gridX = _gridX;
gridY = _gridY;
movementPenalty = _penalty;
}
public void FillWithTile(LevelTilemap level, LevelTileData data)
{
for (int x = 0; x < level.sizeX; x++)
{
for (int y = 0; y < level.sizeY; y++)
{
level.GetITile(x, y).OverrideData(level, data, x, y);
}
}
}
public void FillWithDataName(LevelTilemap level, LevelTileData data)
{
for (int x = 0; x < level.sizeX; x++)
{
for (int y = 0; y < level.sizeY; y++)
{
level.OverrideDataNameTile(x, y, data);
}
}
}
bool IgnoreTile(LevelTileData data)
{
for (int i = 0; i < loseRoomData.ignoreTileList.Count; i++)
{
if (data == loseRoomData.ignoreTileList[i])
{
return(true);
}
}
return(false);
}
public override void EditorApplySaveFileToTile(int x, int y, LevelTileData data)
{
base.EditorApplySaveFileToTile(x, y, data);
var digData = data as LevelTileData_Dig;
if (digData == null)
{
return;
}
SetBackground(x, y, digData.GetBackgroundTile(this, x, y));
}
private void CreateChunk(LevelTileData optionalTileData)
{
GameObject chunk = GameObject.Instantiate(_groundChunkPrefab);
chunk.transform.localScale = new Vector3(ChunkSize.x / 10, 1, ChunkSize.y / 10);
chunk.GetComponent <MeshRenderer>().material.mainTextureScale = new Vector2(ChunkSize.x / 10, ChunkSize.y / 10);
chunk.transform.SetParent(_mill.transform, false);
chunk.transform.localPosition = new Vector3(0, 0, CalculateZPositionByIndex(_amountOfChunksCreated));
_currentlyActiveChunks.Add(new LevelTile(_amountOfChunksCreated, chunk, optionalTileData));
_amountOfChunksCreated++;
}
public GeneratorMapData(int sizeX, int sizeY, LevelTileData defaultTile)
{
this.sizeX = sizeX;
this.sizeY = sizeY;
tiles = new LevelTileData[sizeX * sizeY];
for (int x = 0; x < sizeX; x++)
{
for (int y = 0; y < sizeY; y++)
{
tiles[x + y * sizeX] = defaultTile;
}
}
}
public LevelTileData[] GetTileLevelDataFromSaveFile(TileMapSaveData st)
{
var allData = Resources.LoadAll("", typeof(LevelTileData)).Cast <LevelTileData>().ToArray();
var tiles = new LevelTileData[st.sizeX * st.sizeY];
for (int x = 0; x < st.sizeX; x++)
{
for (int y = 0; y < st.sizeY; y++)
{
tiles[x + y * st.sizeX] = GetDataFromList(st.tiles[x + y * st.sizeX].tileDataName, allData);
}
}
return(tiles);
}
public virtual void LoadChunkFirstTime(int cx, int cy)
{
var chunk = GetTileMap(cx, cy);
if (chunk.isLoaded == true)
{
return;
}
var tiles = new TileBase[chunkSize * chunkSize];
var pos = new Vector3Int[chunkSize * chunkSize];
BaseLevelTile tileTemp = null;
TileBase tileViewTemp = null;
LevelTileData dataTemp = null;
for (int x = 0; x < chunkSize; x++)
{
for (int y = 0; y < chunkSize; y++)
{
vec3IntTemp.x = x + cx * chunkSize;
vec3IntTemp.y = y + cy * chunkSize;
tileTemp = GetITile(vec3IntTemp.x, vec3IntTemp.y);
if (tileTemp != null)
{
dataTemp = tileTemp.data;
}
if (dataTemp != null)
{
tileViewTemp = tileTemp.data.tile;
LoadTileFirstTime(tileTemp);
}
if (tileViewTemp != null)
{
tiles[x + y * chunkSize] = tileViewTemp;
pos[x + y * chunkSize] = vec3IntTemp;
}
else
{
tiles[x + y * chunkSize] = null;
pos[x + y * chunkSize] = vec3IntTemp;
}
dataTemp = null;
tileViewTemp = null;
}
}
chunk.isLoaded = true;
SetTiles(pos, tiles);
}
public TileSaveData GetDataFromColor(Color c, LevelTileData[] allData)
{
LevelTileData data = null;
for (int i = 0; i < allData.Length; i++)
{
if (allData[i].editorColor == c)
{
data = allData[i];
break;
}
}
return(new TileSaveData(data));
}
public LevelTileData GetTile(int x, int y, int sizeX, int sizeY, List <float> randomValue)
{
LevelTileData tile = null;
Vector2 offset = Vector2.zero;
if (randomOffset)
{
offset = new Vector2(Random.Range(0, sizeX), Random.Range(0, sizeY));
}
if (noiseMixer.GetValue((float)(x + offset.x) / sizeX, (float)(y + offset.y) / sizeY, randomValue) > blendFactore)
{
tile = data;
}
return(tile);
}
public void EditorApplySaveFileToTilmap(TileMapSaveData st)
{
ClearTilemap();
var allData = Resources.LoadAll("", typeof(LevelTileData)).Cast <LevelTileData>().ToArray();
LevelTileData tile = null;
Vector3Int pos = new Vector3Int(0, 0, 0);
for (int x = 0; x < st.sizeX; x++)
{
for (int y = 0; y < st.sizeY; y++)
{
tile = GetDataFromList(st.tiles[x + y * st.sizeX].tileDataName, allData);
EditorApplySaveFileToTile(x, y, tile);
}
}
}
public override void OverrideTile(int x, int y, LevelTileData data)
{
base.OverrideTile(x, y, data);
if (IsEmpty(x, y) == false)
{
ShadowOnPos(x, y);
}
var digData = data as LevelTileData_Dig;
if (digData == null)
{
return;
}
SetBackground(x, y, digData.GetBackgroundTile(this, x, y));
}
public void UpdateFromData(LevelTilemap level)
{
LevelTileData data = null;
for (int x = 0; x < chunkSize; x++)
{
for (int y = 0; y < chunkSize; y++)
{
data = tilesData[y * chunkSize + x];
if (data == null)
{
continue;
}
level.tilemap.SetTile(ToTilePosition(x, y), data.GetTile());
}
}
}
public List <bool> GetRightPossibleDoors(LevelTileData floor)
{
var rightPossibleDoors = new List <bool>();
for (int y = 0; y < sizeY; y++)
{
if (PossibleDoorRight(y))
{
rightPossibleDoors.Add(true);
}
else
{
rightPossibleDoors.Add(false);
}
}
return(rightPossibleDoors);
}
public List <bool> GetLeftPossibleDoors(LevelTileData floor)
{
var leftPossibleDoors = new List <bool>();
for (int y = 0; y < sizeY; y++)
{
if (PossibleDoorLeft(y))
{
leftPossibleDoors.Add(true);
}
else
{
leftPossibleDoors.Add(false);
}
}
return(leftPossibleDoors);
}
public virtual void Init(LevelTilemap level, LevelTileData data, Vector3Int pos)
{
this.data = data;
this.pos = pos;
x = pos.x;
y = pos.y;
if (data == null)
{
behavior = null;
}
else
{
behavior = data.GetBehavior();
data.Init(level, this);
behavior.Init(level, this);
}
viewNeedUpdate = true;
if (onInit != null)
{
onInit(level, this);
}
}
public override void Init(LevelTilemap level, LevelTileData data, Vector3Int pos)
{
base.Init(level, data, pos);
currentHealth = MaxHealth;
var digData = data as LevelTileData_Dig;
if (digData == null)
{
return;
}
heat += digData.baseHeat;
light += digData.baseLight;
if (digData.emitHeat != 0)
{
EmitHeat(level, digData);
}
if (digData.emitLight != 0)
{
EmitLight(level, digData);
}
}
public void OverrideDataNameTile(int x, int y, LevelTileData data)
{
tilesData[y * chunkSize + x] = data;
}
public override BaseLevelTile CreateTile(Vector3Int pos, LevelTileData data)
{
return(new LevelTile_Isometric());
}
public LevelTile(int index, GameObject tileGameObject, LevelTileData data)
{
Index = index;
TileInstance = tileGameObject;
LevelTileData = data == null ? new LevelTileData() : data;
}
public List <bool> GetBottomPossibleDoors(LevelTileData floor)
{
return(bottomPossibleDoors);
}
public List <bool> GetTopPossibleDoors(LevelTileData floor)
{
return(topPossibleDoors);
}
public override BaseLevelTile CreateTile(Vector3Int pos, LevelTileData data)
{
return(new TopDownTile());
}
public virtual void EditorApplySaveFileToTile(int x, int y, LevelTileData data)
{
SetTile(IndexToTilemap(x, y), data.GetTile());
}
public void OverrideTile(int x, int y, LevelTileData data)
{
tiles[x + y * sizeX] = data;
}
public void Load(TileMapSaveData st)
{
if (updateVisibleCoroutine != null)
{
StopCoroutine(updateVisibleCoroutine);
}
ClearTilemap();
Resize(st.sizeX, st.sizeY);//inits chunk
LevelTileData tile = null;
//UnityEngine.Debug.Log(sizeX + sizeY * sizeX);
//UnityEngine.Debug.Log(st.tiles.Length);
StringBuilder str = new StringBuilder();
Stopwatch w = new Stopwatch();
str.Append("Load Data : ");
w.Reset();
w.Start();
var allData = Resources.LoadAll("", typeof(LevelTileData)).Cast <LevelTileData>().ToArray();
for (int x = 0; x < st.sizeX; x++)
{
for (int y = 0; y < st.sizeY; y++)
{
tile = GetDataFromList(st.tiles[x + y * st.sizeX].tileDataName, allData);
OverrideDataNameTile(x, y, tile);
}
}
str.AppendLine(" Duration: " + w.Elapsed);
//UpdatePrefabFromData();
//GenerateGridFromPrefab();
str.Append("Init: ");
w.Reset();
w.Start();
InitChunkFromDataName();
Init();
str.AppendLine(" Duration: " + w.Elapsed);
str.Append("TileMap Cleare : ");
w.Reset();
w.Start();
//tilemap.ClearAllTiles();
str.AppendLine(" Duration: " + w.Elapsed);
str.Append("UpdateView : ");
w.Reset();
w.Start();
if (onLoaded != null)
{
onLoaded(this);
}
//UpdateViews();
if (loadAllChunks)
{
for (int x = 0; x < levelChunkX; x++)
{
for (int y = 0; y < levelChunkY; y++)
{
LoadChunkFirstTime(x, y);
}
}
}
str.AppendLine(" Duration: " + w.Elapsed);
#if UNITY_EDITOR
UnityEngine.Debug.Log(str.ToString());
#endif
//if(Application.isEditor == false) {
updateVisibleCoroutine = StartCoroutine(UpdateVisible());
updateAllCoroutine = StartCoroutine(UpdateAllTiles());
//}
}
public override BaseLevelTile CreateTile(Vector3Int pos, LevelTileData data)
{
return(new Tile_SideView());
}
