public void DoAction(AutoTileMap _autoTileMap)
{
int tileMinX = _autoTileMap.MapTileWidth - 1;
int tileMinY = _autoTileMap.MapTileHeight - 1;
int tileMaxX = 0;
int tileMaxY = 0;
for (int i = 0; i < aTileData.Count; ++i)
{
TileData tileData = aTileData[i];
// save prev tile type for undo action
tileData.Tile_type_prev = _autoTileMap.GetAutoTile(tileData.Tile_x, tileData.Tile_y, tileData.Tile_layer).Id;
_autoTileMap.SetAutoTile(tileData.Tile_x, tileData.Tile_y, tileData.Tile_type, tileData.Tile_layer);
tileMinX = Mathf.Min(tileMinX, tileData.Tile_x);
tileMinY = Mathf.Min(tileMinY, tileData.Tile_y);
tileMaxX = Mathf.Max(tileMaxX, tileData.Tile_x);
tileMaxY = Mathf.Max(tileMaxY, tileData.Tile_y);
}
if (_autoTileMap.BrushGizmo.IsRefreshMinimapEnabled)
{
_autoTileMap.RefreshMinimapTexture(tileMinX, tileMinY, (tileMaxX - tileMinX) + 1, (tileMaxY - tileMinY) + 1);
}
_autoTileMap.UpdateChunks();
}
public void Init()
{
m_autoTileMap = GetComponent <AutoTileMap>();
if (m_autoTileMap != null && m_autoTileMap.IsInitialized)
{
m_isInitialized = true;
if (m_autoTileMap.ViewCamera == null)
{
Debug.LogWarning("AutoTileMap has no ViewCamera set. Camera.main will be set as ViewCamera");
m_autoTileMap.ViewCamera = Camera.main;
}
m_camera2D = m_autoTileMap.ViewCamera.GetComponent <Camera2DController>();
if (m_camera2D == null)
{
m_camera2D = m_autoTileMap.ViewCamera.gameObject.AddComponent <Camera2DController>();
}
//MinimapEnabled
// m_autoTileMap.BrushGizmo.gameObject.SetActive(true);
m_autoTileMap.RefreshMinimapTexture();
}
}
/// <summary>
/// Load map serialized data into a map
/// </summary>
/// <param name="_autoTileMap"></param>
public IEnumerator LoadToMap(AutoTileMap _autoTileMap)
{
_autoTileMap.Initialize();
_autoTileMap.ClearMap();
if (!Metadata.IsVersionAboveOrEqual("1.2.4"))
{
_applyFixVersionBelow124(_autoTileMap);
}
int totalMapTiles = TileMapWidth * TileMapHeight;
for (int iLayer = 0; iLayer < TileData.Count; ++iLayer)
{
TileLayer tileData = TileData[iLayer];
_autoTileMap.MapLayers.Add(
new AutoTileMap.MapLayer()
{
Name = tileData.Name,
Visible = tileData.Visible,
LayerType = tileData.LayerType,
SortingOrder = tileData.SortingOrder,
SortingLayer = tileData.SortingLayer,
Depth = tileData.Depth,
TileLayerIdx = iLayer,
});
_autoTileMap.TileLayers.Add(new AutoTile[TileMapWidth * TileMapHeight]);
int iTileRepetition = 1;
int iTileIdx = 0;
for (int i = 0; i < tileData.Tiles.Count; ++i)
{
int iType = tileData.Tiles[i];
//see compression notes in CreateFromTilemap
if (iType < -1)
{
iTileRepetition = -iType;
}
else
{
//+++fix: FogOfWar tiles could be < -1, and this is not good for compress system, excepting ids >= -1
if (tileData.LayerType == eLayerType.FogOfWar)
{
iType = (iType << 1); //restore value so the lost bit was the less significant of last byte
}
//---
if (iTileRepetition > totalMapTiles)
{
Debug.LogError("Error uncompressing layer " + tileData.Name + ". The repetition of a tile was higher than map tiles " + iTileRepetition + " > " + totalMapTiles);
iTileRepetition = 0;
}
for (; iTileRepetition > 0; --iTileRepetition, ++iTileIdx)
{
if (iTileIdx % 10000 == 0)
{
//float loadingPercent = ((float)(iTileIdx + iLayer * TileMapWidth * TileMapHeight)) / (TileMapWidth * TileMapHeight * TileData.Count);
//Debug.Log(" Loading " + (int)(loadingPercent * 100) + "%");
yield return(null);
}
int tile_x = iTileIdx % TileMapWidth;
int tile_y = iTileIdx / TileMapWidth;
if (iType >= 0 || tileData.LayerType == eLayerType.FogOfWar)
{
_autoTileMap.SetAutoTile(tile_x, tile_y, iType, iLayer, false);
}
}
iTileRepetition = 1;
}
}
}
_autoTileMap.RefreshAllTiles();
_autoTileMap.UpdateChunkLayersData();
_autoTileMap.RefreshMinimapTexture();
}
void OnGUI()
{
if (!m_isInitialized)
{
return;
}
if (m_isGuiHidden)
{
m_rEditorRect = new Rect(0, 0, 30, 32);
m_rMapViewRect = new Rect(m_rEditorRect.x + m_rEditorRect.width, 0f, Screen.width - m_rEditorRect.width, Screen.height);
if (GUI.Button(m_rEditorRect, ">"))
{
m_isGuiHidden = false;
}
return;
}
#if UNITY_EDITOR
m_isCtrlKeyHold = Event.current.shift;
#else
m_isCtrlKeyHold = Event.current.control || Event.current.shift;
#endif
Rect vRectTemp;
float fPad = 4f;
float fTilesetOffset = m_isLayersMenuHidden? 64f : 128f;
float fScrollBarWidth = 16f;
float fTileGroupGridHeight = 30f * (1 + (m_tileGroupNames.Length - 1) / 5);
int tilesWidth = k_visualTileWidth * m_autoTileMap.Tileset.AutoTilesPerRow;
int tilesHeight = k_visualTileHeight * (256 / m_autoTileMap.Tileset.AutoTilesPerRow);
m_rEditorRect = new Rect(0f, 0f, tilesWidth + 2 * fPad + fScrollBarWidth, Screen.height);
m_rMapViewRect = new Rect(m_rEditorRect.x + m_rEditorRect.width, 0f, Screen.width - m_rEditorRect.width, Screen.height);
m_rTilesetRect = new Rect(fPad, fTilesetOffset + fPad, tilesWidth + fScrollBarWidth, Screen.height);
m_rTilesetRect.height -= (m_rTilesetRect.y + fPad + fTileGroupGridHeight);
float minimapRectW = Mathf.Min(m_rMapViewRect.width * 0.25f, m_autoTileMap.MinimapTexture.width); // fix to limit the size of minimap for big maps
float minimapRectH = m_autoTileMap.MinimapTexture.height * minimapRectW / m_autoTileMap.MinimapTexture.width;
m_rMinimapRect = new Rect(Screen.width - minimapRectW, Screen.height - minimapRectH, minimapRectW, minimapRectH);
//+++ Draw Tileset Selection Buttons
vRectTemp = new Rect(m_rTilesetRect.x, Screen.height - fTileGroupGridHeight, tilesWidth, fTileGroupGridHeight);
m_subTilesetIdx = GUI.SelectionGrid(vRectTemp, m_subTilesetIdx, m_tileGroupNames, 5);
//---
GUI.Box(m_rEditorRect, "");
if (GUI.Button(new Rect(0, 0, 130, 32), m_showCollisions? "Hide Collisions (C)" : "Show Collisions (C)"))
{
m_showCollisions = !m_showCollisions;
}
if (GUI.Button(new Rect(0, 32, 130, 32), m_showMinimap? "Hide Minimap (M)" : "Show Minimap (M)"))
{
m_showMinimap = !m_showMinimap;
m_autoTileMap.BrushGizmo.IsRefreshMinimapEnabled = m_showMinimap;
if (m_showMinimap)
{
m_autoTileMap.RefreshMinimapTexture();
}
}
if (GUI.Button(new Rect(130, 0, 120, 32), "Save"))
{
m_autoTileMap.ShowSaveDialog();
}
if (GUI.Button(new Rect(130, 32, 120, 32), "Load"))
{
m_autoTileMap.ShowLoadDialog();
}
if (GUI.Button(new Rect(250, 0, 30, 32), "<"))
{
m_isGuiHidden = true;
}
if (GUI.Button(new Rect(250, 32, 30, 32), "L"))
{
m_isLayersMenuHidden = !m_isLayersMenuHidden;
}
if (!m_isLayersMenuHidden)
{
if (GUI.Button(new Rect(0, 64, m_rTilesetRect.width, 32), m_autoTileMap.BrushGizmo.SmartBrushEnabled ? "Smart Brush Enabled" : "Smart Brush Disabled"))
{
m_autoTileMap.BrushGizmo.SmartBrushEnabled = !m_autoTileMap.BrushGizmo.SmartBrushEnabled;
}
comboBoxControl.Rect.y = 96;
comboBoxControl.Rect.width = m_rTilesetRect.width;
comboBoxControl.Rect.height = 32;
m_autoTileMap.BrushGizmo.SelectedLayer = comboBoxControl.Show();
}
if (!comboBoxControl.IsDropDownListVisible)
{
Rect viewRect = new Rect(0, 0, m_rTilesetRect.width - fScrollBarWidth, tilesHeight);
m_scrollPos = GUI.BeginScrollView(m_rTilesetRect, m_scrollPos, viewRect);
//+++ Draw Tiles Thumbnails
{
float fTileRowNb = 32;
vRectTemp = new Rect(0f, 0f, k_visualTileWidth * m_autoTileMap.Tileset.AutoTilesPerRow, k_visualTileHeight * fTileRowNb);
vRectTemp.position += m_rEditorRect.position;
int thumbIdx = 0;
GUI.DrawTexture(vRectTemp, m_thumbnailTextures[m_subTilesetIdx]);
for (int y = 0; thumbIdx < 256; ++y) //256 number of tileset for each tileset group
{
for (int x = 0; x < m_autoTileMap.Tileset.AutoTilesPerRow; ++x, ++thumbIdx)
{
Rect rDst = new Rect(x * k_visualTileWidth, y * k_visualTileHeight, k_visualTileWidth, k_visualTileHeight);
rDst.position += vRectTemp.position;
//if( MyAutoTileMap.IsAutoTileHasAlpha( x, y ) ) GUI.Box( rDst, "A" ); //for debug
if (m_isCtrlKeyHold)
{
string sCollision = "";
switch (m_autoTileMap.Tileset.AutotileCollType[m_subTilesetIdx * 256 + thumbIdx])
{
//NOTE: if you don't see the special characters properly, be sure this file is saved in UTF-8
case AutoTileMap.eTileCollisionType.BLOCK: sCollision = "■"; break;
case AutoTileMap.eTileCollisionType.FENCE: sCollision = "#"; break;
case AutoTileMap.eTileCollisionType.WALL: sCollision = "□"; break;
case AutoTileMap.eTileCollisionType.OVERLAY: sCollision = "★"; break;
}
if (sCollision.Length > 0)
{
GUI.color = new Color(1f, 1f, 1f, 1f);
GUIStyle style = new GUIStyle();
style.fontSize = 30;
style.fontStyle = FontStyle.Bold;
style.alignment = TextAnchor.MiddleCenter;
style.normal.textColor = Color.white;
GUI.Box(rDst, sCollision, style);
GUI.color = Color.white;
}
}
}
}
Rect rSelected = new Rect(0, 0, k_visualTileWidth, k_visualTileHeight);
int tileWithSelectMark = m_selectedTileIdx;
tileWithSelectMark -= (m_subTilesetIdx * 256);
rSelected.position = vRectTemp.position + new Vector2((tileWithSelectMark % m_autoTileMap.Tileset.AutoTilesPerRow) * k_visualTileWidth, (tileWithSelectMark / m_autoTileMap.Tileset.AutoTilesPerRow) * k_visualTileHeight);
UtilsGuiDrawing.DrawRectWithOutline(rSelected, new Color(0f, 0f, 0f, 0.1f), new Color(1f, 1f, 1f, 1f));
}
//----
GUI.EndScrollView();
}
if (m_showMinimap)
{
float minimapScale = m_rMinimapRect.width / m_autoTileMap.MinimapTexture.width;
//NOTE: the texture is drawn blurred in web player unless default quality is set to Fast in project settings
// see here for solution http://forum.unity3d.com/threads/webplayer-gui-issue.100256/#post-868451
GUI.DrawTexture(m_rMinimapRect, m_autoTileMap.MinimapTexture);
UtilsGuiDrawing.DrawRectWithOutline(m_rMinimapRect, new Color(0, 0, 0, 0), Color.black);
// Draw camera region on minimap
Vector3 vCameraPos = m_autoTileMap.ViewCamera.ScreenPointToRay(new Vector3(0, Screen.height - 1)).origin;
int camTileX = (int)(vCameraPos.x / m_autoTileMap.Tileset.TileWorldWidth);
int camTileY = (int)(-vCameraPos.y / m_autoTileMap.Tileset.TileWorldHeight);
Rect rMinimapCam = new Rect(camTileX, camTileY, minimapScale * Screen.width / (m_camera2D.Zoom * m_autoTileMap.Tileset.TileWidth), minimapScale * Screen.height / (m_camera2D.Zoom * m_autoTileMap.Tileset.TileHeight));
rMinimapCam.position *= minimapScale;
rMinimapCam.position += m_rMinimapRect.position;
UtilsGuiDrawing.DrawRectWithOutline(rMinimapCam, new Color(0, 0, 0, 0), Color.white);
// Draw player on minimap
if (m_camera2DFollowBehaviour != null && m_camera2DFollowBehaviour.Target != null)
{
int plyTileX = -1 + (int)(m_camera2DFollowBehaviour.Target.transform.position.x / m_autoTileMap.Tileset.TileWorldWidth);
int plyTileY = -1 + (int)(-m_camera2DFollowBehaviour.Target.transform.position.y / m_autoTileMap.Tileset.TileWorldHeight);
Rect rPlayer = new Rect(plyTileX, plyTileY, 3, 3);
rPlayer.position *= minimapScale;
rPlayer.position += m_rMinimapRect.position;
UtilsGuiDrawing.DrawRectWithOutline(rPlayer, Color.yellow, Color.blue);
}
}
#region Draw Selection Rect
// Map Version
if (m_drawSelectionRect)
{
Rect selRect = new Rect( );
selRect.width = (Mathf.Abs(m_dragTileX - m_startDragTileX) + 1) * m_autoTileMap.Tileset.TileWidth * m_camera2D.Zoom;
selRect.height = (Mathf.Abs(m_dragTileY - m_startDragTileY) + 1) * m_autoTileMap.Tileset.TileHeight * m_camera2D.Zoom;
float worldX = Mathf.Min(m_startDragTileX, m_dragTileX) * m_autoTileMap.Tileset.TileWorldWidth;
float worldY = -Mathf.Min(m_startDragTileY, m_dragTileY) * m_autoTileMap.Tileset.TileWorldHeight;
Vector3 vScreen = m_camera2D.Camera.WorldToScreenPoint(new Vector3(worldX, worldY) + m_autoTileMap.transform.position);
selRect.position = new Vector2(vScreen.x, vScreen.y);
selRect.y = Screen.height - selRect.y;
UtilsGuiDrawing.DrawRectWithOutline(selRect, new Color(0f, 1f, 0f, 0.2f), new Color(0f, 1f, 0f, 1f));
}
// Tileset Version
if (m_tilesetSelStart >= 0 && m_tilesetSelEnd >= 0)
{
int tilesetIdxStart = m_tilesetSelStart - (m_subTilesetIdx * 256); // make it relative to selected tileset
int tilesetIdxEnd = m_tilesetSelEnd - (m_subTilesetIdx * 256); // make it relative to selected tileset
Rect selRect = new Rect( );
int TileStartX = tilesetIdxStart % m_autoTileMap.Tileset.AutoTilesPerRow;
int TileStartY = tilesetIdxStart / m_autoTileMap.Tileset.AutoTilesPerRow;
int TileEndX = tilesetIdxEnd % m_autoTileMap.Tileset.AutoTilesPerRow;
int TileEndY = tilesetIdxEnd / m_autoTileMap.Tileset.AutoTilesPerRow;
selRect.width = (Mathf.Abs(TileEndX - TileStartX) + 1) * k_visualTileWidth;
selRect.height = (Mathf.Abs(TileEndY - TileStartY) + 1) * k_visualTileHeight;
float scrX = Mathf.Min(TileStartX, TileEndX) * k_visualTileWidth;
float scrY = Mathf.Min(TileStartY, TileEndY) * k_visualTileHeight;
selRect.position = new Vector2(scrX, scrY - m_scrollPos.y);
selRect.position += m_rTilesetRect.position;
//selRect.y = Screen.height - selRect.y;
UtilsGuiDrawing.DrawRectWithOutline(selRect, new Color(0f, 1f, 0f, 0.2f), new Color(0f, 1f, 0f, 1f));
}
#endregion
}
//Return only 1 TileData has change
public TileData DoAction(AutoTileMap _autoTileMap)
{
TileData onlyChange = null;
//Check is ok with Size Large
{
var brush = aTileData[0];
int tile_id = brush.Tile_id;
if (_autoTileMap.Tileset.IsExitSlot(tile_id))
{
var slot = _autoTileMap.Tileset.GetSlot(tile_id);
if (slot.Size.x > 1 || slot.Size.y > 1)
{
if (brush.Tile_x < 0)
{
Debug.Log("Out Left Map");
return(onlyChange);
}
if (brush.Tile_y < 0)
{
Debug.Log("Out Top Map");
return(onlyChange);
}
if (brush.Tile_x + slot.Size.x > (_autoTileMap.MapTileWidth))
{
Debug.Log("Out Right Map");
return(onlyChange);
}
if (brush.Tile_y + slot.Size.x > (_autoTileMap.MapTileWidth))
{
Debug.Log("Out Bot Map");
return(onlyChange);
}
//Check all tile will be brush don't have other Size Large
for (int x = brush.Tile_x; x < brush.Tile_x + slot.Size.x; x++)
{
for (int y = brush.Tile_y; y < brush.Tile_y + slot.Size.y; y++)
{
int idCheck = _autoTileMap.GetAutoTile(x, y, brush.Tile_layer).Id;
if (_autoTileMap.Tileset.IsExitSlot(idCheck))
{
var slotCheck = _autoTileMap.Tileset.GetSlot(idCheck);
if (slotCheck.Size.x > 1 || slotCheck.Size.y > 1)
{
Debug.Log("Have other Size Large");
return(onlyChange);
}
}
}
}
}
}
}
//
int tileMinX = _autoTileMap.MapTileWidth - 1;
int tileMinY = _autoTileMap.MapTileHeight - 1;
int tileMaxX = 0;
int tileMaxY = 0;
bool HasChangedTile = false;
for (int i = 0; i < aTileData.Count; ++i)
{
TileData tileData = aTileData[i];
// save prev tile type for undo action
// tileData.Tile_type_prev = _autoTileMap.GetAutoTile( tileData.Tile_x, tileData.Tile_y, tileData.Tile_layer ).Id;
// if(!_autoTileMap.Tileset.IsExitSlot(tileData.Tile_id)){
// continue;
// }
int idCheck = _autoTileMap.GetAutoTile(tileData.Tile_x, tileData.Tile_y, tileData.Tile_layer).Id;
if (_autoTileMap.Tileset.IsExitSlot(idCheck))
{
var slotCheck = _autoTileMap.Tileset.GetSlot(idCheck);
if (!slotCheck.IsCanCopyWhenDraw)
{
continue;
}
}
if (tileData.Tile_id >= -1)
{
bool isUpdate = _autoTileMap.SetAutoTile(tileData.Tile_x, tileData.Tile_y, tileData.Tile_id, tileData.Tile_layer, true);
if (isUpdate)
{
HasChangedTile = true;
}
}
if (tileData.Tile_high >= 0)
{
bool isUpdate = _autoTileMap.MapSelect.SetHighRef(tileData.Tile_x, tileData.Tile_y, tileData.Tile_high);
if (isUpdate)
{
HasChangedTile = true;
int tile_layer_high = (int)eSlotAonTypeLayer.Trigger;
_autoTileMap.RefreshTile(tileData.Tile_x, tileData.Tile_y, tile_layer_high);
}
}
if (aTileData.Count == 1)
{
onlyChange = tileData;
}
// if(slot.Size.x == 1 && slot.Size.y == 1){
// }else{
// // _autoTileMap.SetAutoTile( tileData.Tile_x, tileData.Tile_y, tileData.Tile_id, tileData.Tile_layer );
// for(int x = tileData.Tile_x; x < tileData.Tile_x + slot.Size.x; x++){
// for(int y = tileData.Tile_y; y < tileData.Tile_y + slot.Size.y; y++){
// // _autoTileMap.SetAutoTile( x, y, -2, tileData.Tile_layer );
// _autoTileMap.SetAutoTile( x, y, tileData.Tile_id, tileData.Tile_layer );
// }
// }
// }
if (HasChangedTile)
{
tileMinX = Mathf.Min(tileMinX, tileData.Tile_x);
tileMinY = Mathf.Min(tileMinY, tileData.Tile_y);
tileMaxX = Mathf.Max(tileMaxX, tileData.Tile_x);
tileMaxY = Mathf.Max(tileMaxY, tileData.Tile_y);
}
}
if (HasChangedTile)
{
// if (_autoTileMap.BrushGizmo.IsRefreshMinimapEnabled)
{
_autoTileMap.RefreshMinimapTexture(tileMinX, tileMinY, (tileMaxX - tileMinX) + 1, (tileMaxY - tileMinY) + 1);
}
_autoTileMap.UpdateChunks();
}
return(onlyChange);
}