public int3 WorldPositionToTilePosition(Vector3 worldPos, TileAtlas.TagLayer layer)
{
var rasterSize = layer.rasterSize;
var localP = transform.InverseTransformPoint(worldPos);
return(new int3(Mathf.FloorToInt(localP.x / rasterSize.x), Mathf.RoundToInt(localP.y / rasterSize.y), Mathf.FloorToInt(localP.z / rasterSize.z)));
}
public PlacedTile(string guid, int3 position, TileObject tileObject, GameObject placedObject, TileAtlas.TagLayer layer)
{
this.guid = guid;
this.position = position;
this.tileObject = tileObject;
this.placedObject = placedObject;
this.layer = layer;
}
public void ChangeFloorBoundaries(int3 floorSize, TileAtlas.TagLayer layer)
{
floorBoundaries = new Vector3(
floorSize.x * layer.rasterSize.x,
floorSize.y * layer.rasterSize.y,
floorSize.z * layer.rasterSize.z
);
}
public Vector3 TilePositionToLocalPosition(int3 tilePos, int3 size, TileAtlas.TagLayer layer)
{
var rasterSize = layer.rasterSize;
return(new Vector3(
tilePos.x * rasterSize.x + rasterSize.x * 0.5f * size.x,
tilePos.y * rasterSize.y,
tilePos.z * rasterSize.z + rasterSize.z * 0.5f * size.z
));
}
void AddTileToLayerMenu(TileAtlas atlas, TileAtlas.TagLayer layer, Event e)
{
GenericMenu menu = new GenericMenu();
menu.AddDisabledItem(new GUIContent("Tile from other layer [Not Implemented]"));
menu.AddDisabledItem(new GUIContent("Tile from project files [Not Implemented]"));
menu.AddDisabledItem(new GUIContent("Generate Tile from Gameobject [Not Implemented]"));
menu.AddItem(new GUIContent("Drag and Drop files here!"), true, () => { });
menu.ShowAsContext();
e.Use();
}
public void UpdateTilePositionsOnLayer(TileAtlas.TagLayer layer, int index)
{
if (index == -1)
{
return; // there should be no tiles on defaultlayer
}
Debug.Log("[LevelBuilder] Update Position called on layer " + layer.name + " and index " + index);
foreach (var placed in layers[index].Values)
{
placed.placedObject.transform.localPosition = TilePositionToLocalPosition(placed.position, layer);
}
}
public bool TilePositionInFloorSize(int3 tilePos, TileAtlas.TagLayer layer)
{
var floorSize = FloorSize(layer);
var rasterSize = layer.rasterSize;
int halfX = Mathf.FloorToInt(floorSize.x / 2f); // * rasterSize.x / 2f);
int halfZ = Mathf.FloorToInt(floorSize.z / 2f); // * rasterSize.z / 2f);
if (tilePos.x < -halfX || tilePos.x >= halfX)
{
return(false);
}
if (tilePos.y < -floorSize.y || tilePos.y > floorSize.y)
{
return(false);
}
if (tilePos.z < -halfZ || tilePos.z >= halfZ)
{
return(false);
}
return(true);
}
void DrawOnScreenPalette()
{
bool guiChangedBefore = GUI.changed;
TileAtlas atlas = t.tileSet;
TileAtlas.TagLayer activeLayer = layerIndex == -1 ? atlas.defaultLayer : (layerIndex < atlas.layers.Count) ? atlas.layers[layerIndex] : atlas.defaultLayer;
if (activeLayer == atlas.defaultLayer)
{
return;
}
float scrollBarSize = GUI.skin.verticalScrollbar.fixedWidth;
ChangeVerticalScrollbar(6);
onScreenPaletteScroll = EditorGUILayout.BeginScrollView(onScreenPaletteScroll, GUILayout.Width(52));
List <GUIContent> paletteIcons = new List <GUIContent>();
int maximumPreviewImages = 60;
for (int i = 0; i < atlas.layers.Count; i++)
{
var layer = atlas.layers[i];
if (paletteVisibility == null || paletteVisibility.Length == 0)
{
_paletteVis = new bool[t.tileSet.layers.Count];
}
if (paletteVisibility[i] || layer == activeLayer)
{
foreach (var atlasTile in layer.layerObjects)
{
// Get a preview for the prefab
if (!atlasTile || atlasTile.prefabs.Length == 0)
{
continue;
}
if (layer.layerObjects.Count > maximumPreviewImages)
{
paletteIcons.Add(new GUIContent(atlasTile.name));
}
else
{
Texture2D texture = AssetPreview.GetAssetPreview(atlasTile.prefabs[0]);
paletteIcons.Add(new GUIContent(texture));
}
}
}
}
Rect screenPaletteBox = GUILayoutUtility.GetRect(40, paletteIcons.Count * 40, "CN Box");
int previousItems = 0;
Vector2 layerIndicatorSize = new Vector2(5, 40);
for (int i = 0; i < atlas.layers.Count; i++)
{
if (paletteVisibility[i] || i == layerIndex)
{
for (int j = 0; j < atlas.layers[i].layerObjects.Count; j++)
{
if (i == layerIndex && j == paletteIndex)
{
EditorGUI.DrawRect(new Rect(screenPaletteBox.position + Vector2.up * previousItems * 40, layerIndicatorSize), atlas.layers[i].color + Color.gray);
}
else
{
EditorGUI.DrawRect(new Rect(screenPaletteBox.position + Vector2.up * previousItems * 40, layerIndicatorSize), atlas.layers[i].color);
}
previousItems++;
}
}
}
screenPaletteBox.position += Vector2.right * 5;
int gridIndex = GUI.SelectionGrid(screenPaletteBox, GetIndexFromPaletteIndex(paletteIndex), paletteIcons.ToArray(), 1, "CN Box");
int layerIndexFromPalette;
EditorGUILayout.EndScrollView();
ChangeVerticalScrollbar(scrollBarSize);
if (!guiChangedBefore && GUI.changed)
{
paletteIndex = GetPaletteIndexFromIndex(gridIndex, out layerIndexFromPalette);
layerIndex = layerIndexFromPalette;
Repaint();
}
int GetPaletteIndexFromIndex(int i, out int newLayerIndex)
{
int indexInPalette = 0;
int itemsBefore = 0;
for (int layer = 0; layer < paletteVisibility.Length; layer++)
{
if (paletteVisibility[layer] || layer == layerIndex)
{
itemsBefore += atlas.layers[layer].layerObjects.Count;
if (itemsBefore > i)
{
indexInPalette = i - (itemsBefore - atlas.layers[layer].layerObjects.Count);
newLayerIndex = layer;
//Debug.Log(newLayerIndex);
return(indexInPalette);
}
}
}
newLayerIndex = 0;
return(0);
}
int GetIndexFromPaletteIndex(int pIndex)
{
int offset = 0;
for (int i = 0; i < layerIndex; i++)
{
if (paletteVisibility[i])
{
offset += atlas.layers[i].layerObjects.Count;
}
}
return(pIndex + offset);
}
}
void DrawPalette(TileAtlas atlas, Event e)
{
TileAtlas.TagLayer activeLayer = layerIndex == -1 ? atlas.defaultLayer : (layerIndex < atlas.layers.Count) ? atlas.layers[layerIndex] : atlas.defaultLayer;
//DragTest
//Rect myRect = GUILayoutUtility.GetRect(100, 40, GUILayout.ExpandWidth(true));
//GUI.Box(myRect, "Drag and Drop Prefabs to this Box!");
//if (myRect.Contains(e.mousePosition))
//{
// if (e.type == EventType.DragUpdated)
// {
// DragAndDrop.visualMode = DragAndDropVisualMode.Move;
// //Debug.Log("Drag Updated!");
// e.Use();
// }
// else if (e.type == EventType.DragPerform)
// {
// DragAndDrop.AcceptDrag();
// Debug.Log("Drag Perform!");
// Debug.Log(DragAndDrop.objectReferences.Length);
// if (atlas.layers.Count > 0)
// for (int i = 0; i < DragAndDrop.objectReferences.Length; i++)
// {
// atlas.layers[0].layerObjects.Add(DragAndDrop.objectReferences[i] as TileObject);
// }
// e.Use();
// }
//}
//if (e.type == EventType.DragExited || e.type == EventType.MouseUp)
//{
// //Debug.Log("Drag exited");
// DragAndDrop.PrepareStartDrag();
//}
//------
EditorGUILayout.BeginHorizontal();
EditorGUILayout.BeginVertical();
Color guiColor = GUI.color;
//EditorGUIUtility.IconContent("Settings")
if (GUILayout.Button("Ξ", GUILayout.Width(18), GUILayout.Height(activeLayer == atlas.defaultLayer ? 60 : 30)))
{
layerIndex = -1;
}
for (int i = 0; i < atlas.layers.Count; i++)
{
int index = i;
GUI.color = atlas.layers[i].color;
Rect buttonRect = GUILayoutUtility.GetRect(new GUIContent(i.ToString()), "Button", GUILayout.Width(18), GUILayout.Height(activeLayer == atlas.layers[i] ? 60 : 30));
if (GUI.Button(buttonRect, i.ToString()))
{
layerIndex = i;
if (e.button == 1)
{
LayerRightClickMenu(e, index, atlas);
}
}
}
GUI.color = guiColor;
if (GUILayout.Button("+", GUILayout.Width(18), GUILayout.Height(18)))
{
atlas.AddTagLayer();
}
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical();
if (activeLayer != atlas.defaultLayer)
{
bool changedBefore = GUI.changed;
activeLayer.name = EditorGUILayout.TextField(activeLayer.name);
if (!changedBefore && GUI.changed)
{
UnityEditor.EditorUtility.SetDirty(atlas);
}
}
else
{
EditorGUILayout.HelpBox("Unsorted objects, rightclick and move to a layer to use.", MessageType.Info, true);
}
if (layerIndex >= 0 && layerIndex < atlas.layers.Count)
{
//activeLayer.rasterSize = EditorGUILayout.Vector3Field("raster ", activeLayer.rasterSize);
bool changedBefore = GUI.changed;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Rastersize");
activeLayer.rasterSize.x = EditorGUILayout.DelayedFloatField(activeLayer.rasterSize.x);
activeLayer.rasterSize.y = EditorGUILayout.DelayedFloatField(activeLayer.rasterSize.y);
activeLayer.rasterSize.z = EditorGUILayout.DelayedFloatField(activeLayer.rasterSize.z);
EditorGUILayout.EndHorizontal();
if (!changedBefore && GUI.changed)
{
t.UpdateTilePositionsOnLayer(activeLayer, layerIndex);
}
}
if (activeLayer != atlas.defaultLayer && activeLayer.layerObjects.Count == 0)
{
EditorGUILayout.HelpBox("Drag and Drop Tiles here.", MessageType.Info, true); return;
}
//-----
EditorGUILayout.Vector2Field("scroll", paletteScroll);
float columnCount = 4f;
float panelSize = (position.width - 60) / columnCount;
paletteScroll = EditorGUILayout.BeginScrollView(paletteScroll);
List <GUIContent> paletteIcons = new List <GUIContent>();
float enumerationCount = 0;
if (activeLayer == atlas.defaultLayer)
{
foreach (var atlasTile in atlas.TileFromGuid.Values)
{
// Get a preview for the prefab
if (!atlasTile)
{
continue;
}
Vector2 yValues = new Vector2(Mathf.Floor(enumerationCount / columnCount) * panelSize,
Mathf.Floor(enumerationCount / columnCount) * panelSize + panelSize);
if (yValues.x < paletteScroll.y - panelSize || yValues.y > paletteScroll.y + panelSize * 4 + panelSize) //(atlas.tiles.Count > maximumPreviewImages)
{
paletteIcons.Add(new GUIContent(atlasTile.name));
}
else
{
Texture2D texture = null;
if (atlasTile.prefabs.Length != 0)
{
texture = AssetPreview.GetAssetPreview(atlasTile.prefabs[0]);
}
paletteIcons.Add(texture ? new GUIContent(texture) : new GUIContent("No Preview Available"));
}
enumerationCount++;
}
if (paletteIcons.Count == 0)
{
EditorGUILayout.HelpBox("No unsorted tiles in atlas", MessageType.Info);
}
}
else
{
foreach (var atlasTile in activeLayer.layerObjects)
{
// Get a preview for the prefab
if (!atlasTile)
{
continue;
}
Vector2 yValues = new Vector2(Mathf.Floor(enumerationCount / columnCount) * panelSize,
Mathf.Floor(enumerationCount / columnCount) * panelSize + panelSize);
if (yValues.x < paletteScroll.y - panelSize || yValues.y > paletteScroll.y + panelSize * 4 + panelSize)
{
paletteIcons.Add(new GUIContent(atlasTile.name));
//paletteIcons.Add(new GUIContent($"{enumerationCount} : {yValues}"));
}
else
{
Texture2D texture = null;
if (atlasTile.prefabs.Length != 0)
{
texture = AssetPreview.GetAssetPreview(atlasTile.prefabs[0]);
}
paletteIcons.Add(texture ? new GUIContent(texture) : new GUIContent("No Preview Available"));
}
enumerationCount++;
}
}
if (activeLayer != atlas.defaultLayer)
{
paletteIcons.Add(EditorGUIUtility.IconContent("Toolbar Plus"));
}
// Display the grid
//paletteIndex = GUILayout.SelectionGrid(paletteIndex, paletteIcons.ToArray(), 4, GUILayout.Width(position.width-38));
EditorGUILayout.BeginHorizontal();
GUIStyle iconLabel = new GUIStyle("Label");
iconLabel.alignment = TextAnchor.UpperCenter;
iconLabel.normal.textColor = Color.grey;
for (int i = 0; i < paletteIcons.Count; i++)
{
Rect buttonRect = GUILayoutUtility.GetRect(paletteIcons[i], "Button", GUILayout.Width(panelSize), GUILayout.Height(panelSize));
TileObject buttonTileObject = activeLayer == atlas.defaultLayer ? atlas.tiles[i] : i < activeLayer.layerObjects.Count ? activeLayer.layerObjects[i] : null;
bool clickHere = false;
if (buttonRect.Contains(e.mousePosition))
{
switch (e.type)
{
//case EventType.MouseDrag:
// DragAndDrop.PrepareStartDrag();
// DragAndDrop.SetGenericData("TileObject", buttonTileObject);
// DragAndDrop.objectReferences = new Object[] { buttonTileObject };
// DragAndDrop.StartDrag("Drag");
// break;
//case EventType.DragExited:
// clickHere = true;
// break;
case EventType.MouseDown:
clickHere = true;
break;
}
}
TileAtlas.TagLayer tileLayer = null;
foreach (var layer in atlas.layers)
{
if (layer.layerObjects.Contains(buttonTileObject))
{
tileLayer = layer;
break;
}
}
GUI.backgroundColor = tileLayer != null?tileLayer.color:guiColor;
GUI.Toggle(buttonRect, paletteIndex == i, paletteIcons[i], "Button");
if (buttonTileObject)
{
GUI.Label(buttonRect, buttonTileObject.name, iconLabel);
}
if (clickHere)
{
paletteIndex = i;
if (activeLayer == atlas.defaultLayer)
{
Selection.activeObject = buttonTileObject;
}
if (activeLayer != atlas.defaultLayer && i == paletteIcons.Count - 1)
{
AddTileToLayerMenu(atlas, activeLayer, e);
paletteIndex = 0;
}
else if (e.button == 1) // rightclick
{
TileRightClickMenu(e, buttonTileObject, atlas);
}
}
if (i % (int)(columnCount) == columnCount - 1)// && i != 0)
{
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
}
}
EditorGUILayout.EndHorizontal();
if (activeLayer == atlas.defaultLayer)
{
selectedTileGuid = atlas.tiles[paletteIndex].guid;
}
else
{
if (paletteIndex >= activeLayer.layerObjects.Count)
{
paletteIndex = 0;
}
if (activeLayer.layerObjects[paletteIndex])
{
selectedTileGuid = activeLayer.layerObjects[paletteIndex].guid;
}
else
{
selectedTileGuid = "";
}
}
EditorGUILayout.EndVertical();
EditorGUILayout.EndScrollView();
EditorGUILayout.EndHorizontal();
GUI.backgroundColor = guiColor;
}
void DrawBrushGizmo(int3 brushPosition, int3 brushSize, TileAtlas.TagLayer activeLayer)
{
Handles.DrawWireCube(
t.TilePositionToLocalPosition(brushPosition, brushSize, activeLayer) + Vector3.up * brushSize.y * 0.5f * activeLayer.rasterSize.y,
new Vector3(brushSize.x * activeLayer.rasterSize.x, brushSize.y * activeLayer.rasterSize.y, brushSize.z * activeLayer.rasterSize.z));
}
void OnSceneGridBrush(Event e, SceneView sceneView, TileAtlas.TagLayer activeLayer)
{
if (painting && activeLayer != t.tileSet.defaultLayer)
{
int controlId = GUIUtility.GetControlID(FocusType.Passive);
if (e.control && (e.type == EventType.MouseDown ||
e.type == EventType.MouseDrag ||
e.type == EventType.ScrollWheel))
{
GUIUtility.hotControl = controlId;
if (e.type == EventType.ScrollWheel)
{
if (e.delta.y > 0)
{
targetHeigth -= 1;
}
else
{
targetHeigth += 1;
}
e.Use();
GUIUtility.hotControl = 0;
}
}
if (e.isMouse)
{
Ray guiRay = HandleUtility.GUIPointToWorldRay(e.mousePosition);
float d;
floorPlane.Raycast(guiRay, out d);
Vector3 worldPos = guiRay.GetPoint(d);
//Debug.Log("worldPos: " + worldPos+"; mousePos: "+tileMousePosition);
var newTileMousePosition = t.WorldPositionToTilePosition(worldPos, activeLayer);
if (t.TilePositionInFloorSize(newTileMousePosition, activeLayer))
{
tileMousePosition = newTileMousePosition;
}
}
//Handles.DrawWireDisc(t.TilePositionToLocalPosition(tileMousePosition, selectedTile.size), Vector3.up, 0.5f * selectedTile.size.x);
Handles.color = activeLayer.color + Color.gray;
if (t.GetTile(tileMousePosition, layerIndex) != null)
{
if (e.modifiers == EventModifiers.Control && !tileMousePosition.Equals(lastTileMousePos))
{
tileMousePosition = StackedPosition(tileMousePosition, layerIndex);
}
else
{
Handles.color = new Color(1f, 0.1f, 0f);
}
}
if (e.type == EventType.MouseUp)
{
stackingHeight = null;
}
int3 brushSize = selectedTile ? selectedTile.GetSize(activeLayer.rasterSize) : new int3(1, 1, 1);
DrawBrushGizmo(tileMousePosition, brushSize, activeLayer);
if (rectStartTile != null && !rectStartTile.Value.Equals(tileMousePosition)) // rectbrush
{
for (int x = 0; x <= Mathf.Abs(Mathf.FloorToInt((tileMousePosition.x - rectStartTile.Value.x) / brushSize.x)); x++)
{
for (int z = 0; z <= Mathf.Abs(Mathf.FloorToInt((tileMousePosition.z - rectStartTile.Value.z) / brushSize.z)); z++)
{
DrawBrushGizmo(rectStartTile.Value
+ new int3(
tileMousePosition.x > rectStartTile.Value.x ? x : -x,
0,
tileMousePosition.z > rectStartTile.Value.z ? z : -z), brushSize, activeLayer);
}
}
}
if ((e.type == EventType.MouseDown || e.type == EventType.MouseDrag) && e.button == 0 && (e.modifiers == EventModifiers.None || e.modifiers == EventModifiers.Control))
{
if (!tileMousePosition.Equals(lastTileMousePos) || e.type == EventType.MouseDown)
{
DrawTiles(sceneView, e, tileMousePosition, true);
}
else
{
DrawTiles(sceneView, e, tileMousePosition, false);
}
}
else if ((e.type == EventType.MouseDown || e.type == EventType.MouseDrag) && e.button == 1 &&
(e.modifiers == EventModifiers.None || e.modifiers == EventModifiers.Control))
{
var pos = tileMousePosition;
if (e.modifiers == EventModifiers.Control)
{
int startY = pos.y;
pos = StackedPosition(tileMousePosition, layerIndex, false);
while (pos.y > startY)
{
EraseTiles(sceneView, e, tileMousePosition);
pos.y -= 1;
}
}
EraseTiles(sceneView, e, tileMousePosition);
}
else if (e.type == EventType.MouseDown && (e.button == 0 || e.button == 1) && e.modifiers == EventModifiers.Shift)
{
rectStartTile = tileMousePosition;
GUIUtility.hotControl = 0;
e.Use();
}
else if (e.type == EventType.MouseDrag && (e.button == 0 || e.button == 1) && rectStartTile != null && e.modifiers == EventModifiers.Shift)
{
GUIUtility.hotControl = 0;
e.Use();
}
else if ((e.type == EventType.MouseUp) && (e.button == 0 || e.button == 1) && rectStartTile != null)
{
GUIUtility.hotControl = 0;
e.Use();
if (e.button == 0)
{
DrawMultipleTiles(rectStartTile.Value, tileMousePosition, selectedTile, activeLayer);
}
else if (e.button == 1)
{
EraseMultipleTiles(rectStartTile.Value, tileMousePosition);
}
rectStartTile = null;
}
//else if (e.type == EventType.MouseMove && e.button == 0 && e.modifiers == EventModifiers.Control)
//{
// brushRotation += new Vector3(0, e.delta.x, 0);
// GUIUtility.hotControl = 0;
// e.Use();
// Repaint();
//}
lastTileMousePos = tileMousePosition;
}
}
void DrawMultipleTiles(int3 startPosition, int3 endPosition, TileObject tile, TileAtlas.TagLayer layer)
{
int3 brushSize = tile.GetSize(layer.rasterSize);
int3 minPosition = math.min(startPosition, endPosition);
int3 maxPosition = math.max(startPosition, endPosition);
int widthX = Mathf.FloorToInt((maxPosition.x - minPosition.x) / brushSize.x);
int widthZ = Mathf.FloorToInt((maxPosition.z - minPosition.z) / brushSize.z);
for (int x = 0; x <= widthX; x++)
{
for (int z = 0; z <= widthZ; z++)
{
t.PlaceTile(tile.guid,
minPosition + new int3(
x * brushSize.x,
0,
z * brushSize.z),
brushRotation,
layerIndex, layer, true); // <-- turn to false if performance becomes problematic
}
}
//t.UpdateMultiple(minPosition - new int3(1, 0, 1), maxPosition + new int3(2,0,2), layerIndex);
}
public int3 FloorSize(TileAtlas.TagLayer layer)
{
return(FloorSize(layer.rasterSize));
}
public void PlaceTile(string guid, int3 position, Vector3 euler, int layerIndex, TileAtlas.TagLayer tagLayer, bool updateNeighbours = true)
{
Undo.RegisterCompleteObjectUndo(this, "Created New Tile Object");
TileObject atlasTile;
tileSet.TileFromGuid.TryGetValue(guid, out atlasTile);
if (!atlasTile)
{
Debug.LogError("No Tile with guid [" + guid + "] found in atlas " + tileSet.name, tileSet); return;
}
var go = (GameObject)PrefabUtility.InstantiatePrefab(atlasTile.prefab) as GameObject;
if (!go)
{
Debug.LogError("No GameObject found at Tile with guid " + guid); return;
}
if (layerIndex >= layers.Count)
{
for (int i = 0; i <= layerIndex - layers.Count; i++)
{
layers.Add(new IntTileDictionary());
}
}
int3 tileSize = atlasTile.GetSize(tagLayer.rasterSize);
go.transform.SetParent(transform);
if (!hierarchyVisibility)
{
go.hideFlags |= HideFlags.HideInHierarchy;
}
//atlasTile.size
go.transform.localPosition = TilePositionToLocalPosition(position, tileSize, tileSet.layers[layerIndex]) + atlasTile.offset;
go.transform.localRotation = Quaternion.Euler(euler);
var placedTile = new PlacedTile(guid, position, atlasTile, go, tagLayer);
for (int x = 0; x < tileSize.x; x++)
{
for (int y = 0; y < tileSize.y; y++)
{
for (int z = 0; z < tileSize.z; z++)
{
var pos = position + new int3(x, y, z);
PlacedTile alreadyPlaced;
if (layers[layerIndex].TryGetValue(pos, out alreadyPlaced))
{
RemoveTile(alreadyPlaced, layerIndex);
}
if (layers[layerIndex].ContainsKey(pos))
{
layers[layerIndex].Remove(pos);
}
layers[layerIndex].Add(pos, placedTile);
}
}
}
var neighbs = GetNeighbours(placedTile, layerIndex);
atlasTile.PlaceBehaviour(placedTile, neighbs);
if (updateNeighbours)
{
foreach (var neighb in neighbs)
{
//Undo.RecordObject(neighb.placedObject, "Before Updating Object");
neighb.tileObject.UpdateBehaviour(neighb, GetNeighbours(neighb, layerIndex));
}
}
Undo.RegisterCreatedObjectUndo(placedTile.placedObject, "Created New Tile Object");
EditorUtility.SetDirty(gameObject);
}
