public void SetActiveBrushCallback_DoesNotCallWhenSetWithSameBrush()
{
CreatePaletteWindow();
GridPaintingState.gridBrush = GetDefaultBrush();
var brushChangedCount = 0;
GridBrushBase brushToChange = null;
var brushChangedDelegate = new Action <GridBrushBase>(changedBrush =>
{
Assert.AreEqual(brushToChange, changedBrush);
++brushChangedCount;
});
GridPaintingState.brushChanged += brushChangedDelegate;
try
{
var customBrush = GetCustomBrush();
brushToChange = customBrush;
GridPaintingState.gridBrush = customBrush;
Assert.AreEqual(1, brushChangedCount);
GridPaintingState.gridBrush = customBrush;
Assert.AreEqual(1, brushChangedCount);
}
finally
{
GridPaintingState.brushChanged -= brushChangedDelegate;
}
}
private string GetBrushDropdownName(GridBrushBase brush)
{
string result;
if (!GridPaletteBrushes.IsLibraryBrush(brush))
{
result = brush.name;
}
else
{
CustomGridBrushAttribute[] array = brush.GetType().GetCustomAttributes(typeof(CustomGridBrushAttribute), false) as CustomGridBrushAttribute[];
if (array != null && array.Length > 0 && array[0].defaultName.Length > 0)
{
result = array[0].defaultName;
}
else if (brush.GetType() == typeof(GridBrush))
{
result = "Default Brush";
}
else
{
result = brush.GetType().Name;
}
}
return(result);
}
private void CallOnPaintSceneGUI(Vector2Int position)
{
if (this.unlocked || EditMode.editMode == EditMode.SceneViewEditMode.GridSelect || EditMode.editMode == EditMode.SceneViewEditMode.GridPicking)
{
bool flag = GridSelection.active && GridSelection.target == this.brushTarget;
if (flag || !(GridPaintingState.activeGrid != this))
{
GridBrushBase gridBrush = GridPaintingState.gridBrush;
if (!(gridBrush == null))
{
RectInt marqueeRect = new RectInt(position, new Vector2Int(1, 1));
if (this.m_MarqueeStart.HasValue)
{
marqueeRect = GridEditorUtility.GetMarqueeRect(position, this.m_MarqueeStart.Value);
}
else if (flag)
{
marqueeRect = new RectInt(GridSelection.position.xMin, GridSelection.position.yMin, GridSelection.position.size.x, GridSelection.position.size.y);
}
GridLayout gridLayout = (!(this.tilemap != null)) ? this.grid : this.tilemap;
BoundsInt position2 = new BoundsInt(new Vector3Int(marqueeRect.x, marqueeRect.y, 0), new Vector3Int(marqueeRect.width, marqueeRect.height, 1));
if (GridPaintingState.activeBrushEditor != null)
{
GridPaintingState.activeBrushEditor.OnPaintSceneGUI(gridLayout, this.brushTarget, position2, PaintableGrid.EditModeToBrushTool(EditMode.editMode), this.m_MarqueeStart.HasValue || base.executing);
}
else
{
GridBrushEditorBase.OnPaintSceneGUIInternal(gridLayout, Selection.activeGameObject, position2, PaintableGrid.EditModeToBrushTool(EditMode.editMode), this.m_MarqueeStart.HasValue || base.executing);
}
}
}
}
}
private void RefreshBrushesCache()
{
if (m_Brushes == null)
{
m_Brushes = new List <GridBrushBase>();
}
GridBrushBase defaultBrush = null;
if (m_Brushes.Count == 0 || !(m_Brushes[0] is GridBrush))
{
System.Type defaultType = GetDefaultBrushType();
defaultBrush = LoadOrCreateLibraryGridBrushAsset(defaultType);
m_Brushes.Insert(0, defaultBrush);
m_Brushes[0].name = GetBrushDropdownName(m_Brushes[0]);
}
var editorAssemblies = EditorAssemblies.loadedAssemblies;
foreach (var editorAssembly in editorAssemblies)
{
try
{
IEnumerable <Type> brushTypes = editorAssembly.GetTypes().Where(t => t != typeof(GridBrushBase) && t != typeof(GridBrush) && typeof(GridBrushBase).IsAssignableFrom(t));
foreach (var brushType in brushTypes)
{
if (IsDefaultInstanceVisibleGridBrushType(brushType))
{
var brush = LoadOrCreateLibraryGridBrushAsset(brushType);
if (brush != null)
{
m_Brushes.Add(brush);
}
}
}
}
catch (Exception ex)
{
Debug.Log(string.Format("TilePalette failed to get types from {0}. Error: {1}", editorAssembly.FullName, ex.Message));
}
}
string[] guids = AssetDatabase.FindAssets("t:GridBrushBase");
foreach (string guid in guids)
{
string path = AssetDatabase.GUIDToAssetPath(guid);
var brush = AssetDatabase.LoadAssetAtPath(path, typeof(GridBrushBase)) as GridBrushBase;
if (brush != null && IsAssetVisibleGridBrushType(brush.GetType()))
{
m_Brushes.Add(brush);
}
}
m_BrushNames = new string[m_Brushes.Count];
for (int i = 0; i < m_Brushes.Count; i++)
{
m_BrushNames[i] = m_Brushes[i].name;
}
}
private void RefreshBrushesCache()
{
if (this.m_Brushes == null)
{
this.m_Brushes = new List <GridBrushBase>();
}
if (this.m_Brushes.Count == 0 || !(this.m_Brushes[0] is GridBrush))
{
Type defaultBrushType = GridPaletteBrushes.GetDefaultBrushType();
GridBrushBase item = this.LoadOrCreateLibraryGridBrushAsset(defaultBrushType);
this.m_Brushes.Insert(0, item);
this.m_Brushes[0].name = this.GetBrushDropdownName(this.m_Brushes[0]);
}
Assembly[] loadedAssemblies = EditorAssemblies.loadedAssemblies;
Assembly[] array = loadedAssemblies;
for (int i = 0; i < array.Length; i++)
{
Assembly assembly = array[i];
try
{
IEnumerable <Type> enumerable = from t in assembly.GetTypes()
where t != typeof(GridBrushBase) && t != typeof(GridBrush) && typeof(GridBrushBase).IsAssignableFrom(t)
select t;
foreach (Type current in enumerable)
{
if (this.IsDefaultInstanceVisibleGridBrushType(current))
{
GridBrushBase gridBrushBase = this.LoadOrCreateLibraryGridBrushAsset(current);
if (gridBrushBase != null)
{
this.m_Brushes.Add(gridBrushBase);
}
}
}
}
catch (Exception ex)
{
Debug.Log(string.Format("TilePalette failed to get types from {0}. Error: {1}", assembly.FullName, ex.Message));
}
}
string[] array2 = AssetDatabase.FindAssets("t:GridBrushBase");
string[] array3 = array2;
for (int j = 0; j < array3.Length; j++)
{
string guid = array3[j];
string assetPath = AssetDatabase.GUIDToAssetPath(guid);
GridBrushBase gridBrushBase2 = AssetDatabase.LoadAssetAtPath(assetPath, typeof(GridBrushBase)) as GridBrushBase;
if (gridBrushBase2 != null && this.IsAssetVisibleGridBrushType(gridBrushBase2.GetType()))
{
this.m_Brushes.Add(gridBrushBase2);
}
}
this.m_BrushNames = new string[this.m_Brushes.Count];
for (int k = 0; k < this.m_Brushes.Count; k++)
{
this.m_BrushNames[k] = this.m_Brushes[k].name;
}
}
private void OnBrushChanged(GridBrushBase brush)
{
DisableFocus();
if (brush is GridBrush)
{
EnableFocus();
}
SceneView.RepaintAll();
}
private GridBrushBase CreateLibraryGridBrushAsset(Type brushType)
{
GridBrushBase brush = ScriptableObject.CreateInstance(brushType) as GridBrushBase;
brush.hideFlags = HideFlags.DontSave;
brush.name = GetBrushDropdownName(brush);
SaveLibraryGridBrushAsset(brush);
return(brush);
}
private GridBrushBase CreateLibraryGridBrushAsset(Type brushType)
{
GridBrushBase gridBrushBase = ScriptableObject.CreateInstance(brushType) as GridBrushBase;
gridBrushBase.hideFlags = HideFlags.DontSave;
gridBrushBase.name = this.GetBrushDropdownName(gridBrushBase);
this.SaveLibraryGridBrushAsset(gridBrushBase);
return(gridBrushBase);
}
private void SaveLibraryGridBrushAsset(GridBrushBase brush)
{
var gridBrushPath = GenerateGridBrushInstanceLibraryPath(brush.GetType());
string folderPath = Path.GetDirectoryName(gridBrushPath);
if (!Directory.Exists(folderPath))
{
Directory.CreateDirectory(folderPath);
}
InternalEditorUtility.SaveToSerializedFileAndForget(new[] { brush }, gridBrushPath, true);
}
public bool Build(GridBrushBase Brush, int x, int y)
{
var pos = new Vector3Int(x, y, 0);
if (!AstarPath.active.graphs[0].GetNearest(pos).node.Walkable)
{
return(false);
}
Brush.Paint(GridObject.GetComponent <Grid>(), Obstacles.gameObject, pos);
//AstarPath.active.graphs[0].GetNearest(new Vector3(x, y)).node.Walkable = false;
return(true);
}
private void SaveLibraryGridBrushAsset(GridBrushBase brush)
{
string path = this.GenerateGridBrushInstanceLibraryPath(brush.GetType());
string directoryName = Path.GetDirectoryName(path);
if (!Directory.Exists(directoryName))
{
Directory.CreateDirectory(directoryName);
}
InternalEditorUtility.SaveToSerializedFileAndForget(new GridBrushBase[]
{
brush
}, path, true);
}
private GridBrushBase LoadOrCreateLibraryGridBrushAsset(Type brushType)
{
var serializedObjects = InternalEditorUtility.LoadSerializedFileAndForget(GenerateGridBrushInstanceLibraryPath(brushType));
if (serializedObjects != null && serializedObjects.Length > 0)
{
GridBrushBase brush = serializedObjects[0] as GridBrushBase;
if (brush != null && brush.GetType() == brushType)
{
return(brush);
}
}
return(CreateLibraryGridBrushAsset(brushType));
}
private void CallOnPaintSceneGUI(Vector2Int position)
{
if (!unlocked && !TilemapEditorTool.IsActive(typeof(SelectTool)) && !TilemapEditorTool.IsActive(typeof(PickingTool)))
{
return;
}
bool hasSelection = GridSelection.active && GridSelection.target == brushTarget;
if (!hasSelection && GridPaintingState.activeGrid != this)
{
return;
}
GridBrushBase brush = GridPaintingState.gridBrush;
if (brush == null)
{
return;
}
var rect = new RectInt(position, new Vector2Int(1, 1));
if (m_MarqueeStart.HasValue)
{
rect = GridEditorUtility.GetMarqueeRect(position, m_MarqueeStart.Value);
}
else if (hasSelection)
{
rect = new RectInt(GridSelection.position.xMin, GridSelection.position.yMin, GridSelection.position.size.x, GridSelection.position.size.y);
}
var gridLayout = tilemap != null ? tilemap.layoutGrid : grid as GridLayout;
BoundsInt brushBounds = new BoundsInt(new Vector3Int(rect.x, rect.y, zPosition), new Vector3Int(rect.width, rect.height, 1));
if (GridPaintingState.activeBrushEditor != null)
{
GridPaintingState.activeBrushEditor.OnPaintSceneGUI(gridLayout, brushTarget, brushBounds,
EditTypeToBrushTool(UnityEditor.EditorTools.ToolManager.activeToolType),
m_MarqueeStart.HasValue || executing);
}
else // Fallback when user hasn't defined custom editor
{
GridBrushEditorBase.OnPaintSceneGUIInternal(gridLayout, Selection.activeGameObject, brushBounds,
EditTypeToBrushTool(UnityEditor.EditorTools.ToolManager.activeToolType),
m_MarqueeStart.HasValue || executing);
}
}
private GridBrushBase LoadOrCreateLibraryGridBrushAsset(Type brushType)
{
UnityEngine.Object[] array = InternalEditorUtility.LoadSerializedFileAndForget(this.GenerateGridBrushInstanceLibraryPath(brushType));
GridBrushBase result;
if (array != null && array.Length > 0)
{
GridBrushBase gridBrushBase = array[0] as GridBrushBase;
if (gridBrushBase != null && gridBrushBase.GetType() == brushType)
{
result = gridBrushBase;
return(result);
}
}
result = this.CreateLibraryGridBrushAsset(brushType);
return(result);
}
private void RefreshBrushesCache()
{
if (m_Brushes == null)
{
m_Brushes = new List <GridBrushBase>();
}
if (m_Brushes.Count == 0 || !(m_Brushes[0] is GridBrush))
{
Type defaultType = GetDefaultBrushType();
GridBrushBase defaultBrush = LoadOrCreateLibraryGridBrushAsset(defaultType);
m_Brushes.Insert(0, defaultBrush);
m_Brushes[0].name = GetBrushDropdownName(m_Brushes[0]);
}
var brushTypes = TypeCache.GetTypesDerivedFrom <GridBrushBase>().Where(t => t != typeof(GridBrush));
foreach (var brushType in brushTypes)
{
if (IsDefaultInstanceVisibleGridBrushType(brushType))
{
var brush = LoadOrCreateLibraryGridBrushAsset(brushType);
if (brush != null)
{
m_Brushes.Add(brush);
}
}
}
string[] guids = AssetDatabase.FindAssets("t:GridBrushBase");
foreach (string guid in guids)
{
string path = AssetDatabase.GUIDToAssetPath(guid);
var brush = AssetDatabase.LoadAssetAtPath(path, typeof(GridBrushBase)) as GridBrushBase;
if (brush != null && IsAssetVisibleGridBrushType(brush.GetType()))
{
m_Brushes.Add(brush);
}
}
m_BrushNames = new string[m_Brushes.Count];
for (int i = 0; i < m_Brushes.Count; i++)
{
m_BrushNames[i] = m_Brushes[i].name;
}
}
private void CallOnPaintSceneGUI(Vector2Int position)
{
if (!unlocked && EditMode.editMode != EditMode.SceneViewEditMode.GridSelect && EditMode.editMode != EditMode.SceneViewEditMode.GridPicking)
{
return;
}
bool hasSelection = GridSelection.active && GridSelection.target == brushTarget;
if (!hasSelection && GridPaintingState.activeGrid != this)
{
return;
}
GridBrushBase brush = GridPaintingState.gridBrush;
if (brush == null)
{
return;
}
RectInt rect = new RectInt(position, new Vector2Int(1, 1));
if (m_MarqueeStart.HasValue)
{
rect = GridEditorUtility.GetMarqueeRect(position, m_MarqueeStart.Value);
}
else if (hasSelection)
{
rect = new RectInt(GridSelection.position.xMin, GridSelection.position.yMin, GridSelection.position.size.x, GridSelection.position.size.y);
}
var gridLayout = tilemap != null ? tilemap as GridLayout : grid as GridLayout;
BoundsInt brushBounds = new BoundsInt(new Vector3Int(rect.x, rect.y, 0), new Vector3Int(rect.width, rect.height, 1));
if (GridPaintingState.activeBrushEditor != null)
{
GridPaintingState.activeBrushEditor.OnPaintSceneGUI(gridLayout, brushTarget, brushBounds, EditModeToBrushTool(EditMode.editMode), m_MarqueeStart.HasValue || executing);
}
else // Fallback when user hasn't defined custom editor
{
GridBrushEditorBase.OnPaintSceneGUIInternal(gridLayout, Selection.activeGameObject, brushBounds, EditModeToBrushTool(EditMode.editMode), m_MarqueeStart.HasValue || executing);
}
}
private void OnBrushInspectorGUI()
{
GridBrushBase gridBrush = GridPaintingState.gridBrush;
if (!(gridBrush == null))
{
EditorGUI.BeginChangeCheck();
if (GridPaintingState.activeBrushEditor != null)
{
GridPaintingState.activeBrushEditor.OnPaintInspectorGUI();
}
else if (GridPaintingState.fallbackEditor != null)
{
GridPaintingState.fallbackEditor.OnInspectorGUI();
}
if (EditorGUI.EndChangeCheck())
{
GridPaletteBrushes.ActiveGridBrushAssetChanged();
}
}
}
private string GetBrushDropdownName(GridBrushBase brush)
{
// Asset Brushes use the asset name
if (!IsLibraryBrush(brush))
{
return(brush.name);
}
// Library Brushes
CustomGridBrushAttribute[] customBrushes = brush.GetType().GetCustomAttributes(typeof(CustomGridBrushAttribute), false) as CustomGridBrushAttribute[];
if (customBrushes != null && customBrushes.Length > 0 && customBrushes[0].defaultName.Length > 0)
{
return(customBrushes[0].defaultName);
}
if (brush.GetType() == typeof(GridBrush))
{
return("Default Brush");
}
return(brush.GetType().Name);
}
public void SelectElement(int idx_)
{
switch (idx_)
{
case 0:
selectedElement = BuildBrush[idx_];
break;
case 1:
selectedElement = BuildBrush[idx_];
break;
case 2:
selectedElement = BuildBrush[idx_];
break;
case 3:
selectedElement = BuildBrush[idx_];
break;
default:
break;
}
}
private void OnBrushChanged(GridBrushBase brush)
{
UpdateCache();
}
public void StoreLastUsedBrush(GridBrushBase brush)
{
int index = brushes.IndexOf(brush);
SessionState.SetInt(s_SessionStateLastUsedBrush, index);
}
private static bool IsLibraryBrush(GridBrushBase brush)
{
return(!AssetDatabase.Contains(brush));
}
void Start()
{
playerResourcesScript = GetComponent <PlayerResources>();
selectedElement = null;
cam = Camera.main;
}
