public AutoTile GetAutoTile(int gridX, int gridY, int iLayer)
{
if (IsValidAutoTilePos(gridX, gridY) && iLayer < MapLayers.Count)
{
// AutoTile autoTile = TileLayers[MapLayers[iLayer].TileLayerIdx][gridX + gridY * MapTileWidth];
AutoTile autoTile = TileLayers[iLayer][gridX, gridY];
if (autoTile != null)
{
return(autoTile);
}
return(new AutoTile()
{
Id = k_emptyTileId,
TileX = gridX,
TileY = gridY,
Layer = iLayer
});
}
return(new AutoTile()
{
Id = k_outofboundsTileId,
TileX = gridX,
TileY = gridY,
Layer = iLayer
});
}
public void RefreshTile(AutoTile autoTile)
{
if (autoTile == null)
{
return;
}
TileChunkPoolNode.MarkUpdatedTile(autoTile.TileX, autoTile.TileY, autoTile.Layer);
}
public void ClearLayer(MapLayer mapLayer)
{
for (int i = 0; i < TileLayers[mapLayer.TileLayerIdx].Length; ++i)
{
for (int gridX = 0; gridX < MapTileWidth; gridX++)
{
for (int gridY = 0; gridY < MapTileHeight; gridY++)
{
AutoTile autoTile = TileLayers[mapLayer.TileLayerIdx][gridX, gridY];
if (autoTile != null)
{
autoTile.Id = -1;
}
}
}
}
}
public bool SetAutoTile(int gridX, int gridY, int tileId, int iLayer, bool checkRefreshTile)
{
if (!IsValidAutoTilePos(gridX, gridY) || iLayer >= MapLayers.Count)
{
return(false);
}
bool tileHasChange = false;
{
// int idx = gridX + gridY * MapTileWidth;
// AutoTile autoTile = TileLayers[MapLayers[iLayer].TileLayerIdx][idx];
AutoTile autoTile = TileLayers[iLayer][gridX, gridY];
if (autoTile == null)
{
autoTile = new AutoTile();
// TileLayers[MapLayers[iLayer].TileLayerIdx][idx] = autoTile;
TileLayers[iLayer][gridX, gridY] = autoTile;
}
tileHasChange = autoTile.Id != tileId;
autoTile.Id = tileId;
autoTile.TileX = gridX;
autoTile.TileY = gridY;
autoTile.Layer = iLayer;
if (checkRefreshTile && tileHasChange)
{
for (int xf = -1; xf < 2; ++xf)
{
for (int yf = -1; yf < 2; ++yf)
{
RefreshTile(gridX + xf, gridY + yf, iLayer);
}
}
}
}
return(tileHasChange);
}
/// <summary>
/// Save the map configuration
/// </summary>
/// <param name="_autoTileMap"></param>
/// <returns></returns>
public bool SaveData(AutoTileMap _autoTileMap)
{
int width = TileMapWidth;
int height = TileMapHeight;
// avoid clear map data when auto tile map is not initialized
if (!_autoTileMap.IsInitialized)
{
//Debug.LogError(" Error saving data. Autotilemap is not initialized! Map will not be saved. ");
return(false);
}
Metadata.version = MetadataChunk.k_version;
TileData.Clear();
// TriggerLink.Clear();
// WarpsData.Clear();
// SignpostsData.Clear();
// ScriptData.Clear();
bool isEnableCompression = true;
for (int iLayer = 0; iLayer < _autoTileMap.GetLayerCount(); ++iLayer)
{
AutoTileMap.MapLayer mapLayer = _autoTileMap.MapLayers[iLayer];
List <int> tileData = new List <int>(width * height);
int iTileRepetition = 0;
int savedTileId = 0;
int mapWidth = _autoTileMap.MapTileWidth;
int mapHeight = _autoTileMap.MapTileHeight;
for (int tile_y = 0; tile_y < height; ++tile_y)
{
for (int tile_x = 0; tile_x < width; ++tile_x)
{
int iType = -1;
if (tile_x < mapWidth && tile_y < mapHeight)
{
// AutoTile autoTile = _autoTileMap.TileLayers[_autoTileMap.MapLayers[iLayer].TileLayerIdx][tile_x + tile_y * mapWidth];
AutoTile autoTile = _autoTileMap.TileLayers[iLayer][tile_x, tile_y];
iType = autoTile != null? autoTile.Id : -1;
}
if (isEnableCompression)
{
if (iTileRepetition == 0)
{
savedTileId = iType;
iTileRepetition = 1;
}
else
{
// compression data. All tiles of the same type are store with number of repetitions ( negative number ) and type
// ex: 5|5|5|5 --> |-4|5| (4 times 5) ex: -1|-1|-1 --> |-3|-1| ( 3 times -1 )
if (iType == savedTileId)
{
++iTileRepetition;
}
else
{
if (iTileRepetition > 1)
{
tileData.Add(-iTileRepetition); // save number of repetition with negative sign
}
if (savedTileId < -1)
{
Debug.LogError(" Wrong tile id found when compressing the tile layer " + mapLayer.Name);
savedTileId = -1;
}
tileData.Add(savedTileId);
savedTileId = iType;
iTileRepetition = 1;
}
}
}
else
{
tileData.Add(iType); // save number of repetition with negative sign
}
}
}
if (isEnableCompression)
{
// save last tile type found
if (iTileRepetition > 1)
{
tileData.Add(-iTileRepetition);
}
tileData.Add(savedTileId);
}
//
TileData.Add(new TileLayer()
{
Tiles = tileData,
Depth = mapLayer.Depth,
LayerType = mapLayer.LayerType,
SortingLayer = mapLayer.SortingLayer,
SortingOrder = mapLayer.SortingOrder,
Name = mapLayer.Name,
Visible = mapLayer.Visible
});
}
TileMapWidth = width;
TileMapHeight = height;
//Compression Data
OverlayLink_C = CreateCompressionArray(OverlayLink);
TriggerLink_C = CreateCompressionArray(TriggerLink);
High_C = CreateCompressionArray(High);
OverlayRotate_C = CreateCompressionArray(OverlayRotate);
// RawFlagMap.Data = FlagMap;
RawFlagAction = new List <FlagAction.SerializableFlagAction>(ListFlagAction.Count);
for (int i = 0; i < ListFlagAction.Count; i++)
{
var r = new FlagAction.SerializableFlagAction();
r.FlagAction = ListFlagAction[i];
RawFlagAction.Add(r);
}
Debug.Log("Save with Compression");
return(true);
}
public void RefreshTile(int gridX, int gridY, int iLayer)
{
AutoTile autoTile = GetAutoTile(gridX, gridY, iLayer);
RefreshTile(autoTile);
}
/// <summary>
/// Copy a section of the map and use it as drawing template
/// </summary>
/// <param name="tile_start_x"></param>
/// <param name="tile_start_y"></param>
/// <param name="tile_end_x"></param>
/// <param name="tile_end_y"></param>
/// <param name="_dragEndTileX"></param>
/// <param name="_dragEndTileY"></param>
/// <param name="isCtrlKeyHold"></param>
public void RefreshBrushGizmo(int tile_start_x, int tile_start_y, int tile_end_x, int tile_end_y, int _dragEndTileX, int _dragEndTileY, bool isCtrlKeyHold)
{
Vector2 pivot = new Vector2(0f, 1f);
SpriteRenderer[] aSprites = GetComponentsInChildren <SpriteRenderer>();
int sprIdx = 0;
for (int tile_x = tile_start_x; tile_x <= tile_end_x; ++tile_x)
{
for (int tile_y = tile_start_y; tile_y <= tile_end_y; ++tile_y)
{
for (int tile_layer = 0; tile_layer < MyAutoTileMap.GetLayerCount(); ++tile_layer)
{
// if(
// (isCtrlKeyHold && tile_layer == SelectedLayer) || //copy all layers over the SelectedLayer
// !MyAutoTileMap.MapLayers[tile_layer].Visible // skip invisible layers
// )
// {
// continue;
// }
AutoTile autoTile = MyAutoTileMap.GetAutoTile(tile_x, tile_y, tile_layer);
if (autoTile != null && autoTile.Id >= 0)
{
// for( int partIdx = 0; partIdx < autoTile.TilePartsLength; ++partIdx, ++sprIdx )
// {
int idSlot = autoTile.Id;
if (!MyAutoTileMap.Tileset.IsExitSlot(idSlot))
{
continue;
}
var slot = MyAutoTileMap.Tileset.GetSlot(idSlot);
if (!slot.IsCanCopyWhenDraw)
{
continue;
}
SpriteRenderer spriteRender = GetSpriteRenderer(aSprites, ref sprIdx);
SetSpriteRendererSlot(spriteRender, slot, pivot);
spriteRender.sortingOrder = 50; //TODO: +50 temporal? see for a const number later
// get last tile as relative position
int tilePart_x = (tile_x - _dragEndTileX) * 2;
int tilePart_y = (tile_y - _dragEndTileY) * 2;
float xFactor = MyAutoTileMap.CellSize.x / 2f;
float yFactor = MyAutoTileMap.CellSize.y / 2f;
spriteRender.transform.localPosition = new Vector3(tilePart_x * xFactor, -tilePart_y * yFactor, spriteRender.transform.position.z);
spriteRender.transform.localScale = new Vector3(MyAutoTileMap.CellSize.x * AutoTileset.PixelToUnits / MyAutoTileMap.Tileset.TileWidth, MyAutoTileMap.CellSize.y * AutoTileset.PixelToUnits / MyAutoTileMap.Tileset.TileHeight, 1f);
// }
}
}
}
}
// clean unused sprite objects
while (sprIdx < aSprites.Length)
{
if (Application.isEditor)
{
DestroyImmediate(aSprites[sprIdx].transform.gameObject);
}
else
{
Destroy(aSprites[sprIdx].transform.gameObject);
}
++sprIdx;
}
}
