public static void CheckForErrors(UnityEngine.Object targetObject)
{
if (targetObject == null)
{
return;
}
if (targetObject.GetType() == typeof(StateMachine))
{
checkingStateMachine = targetObject as StateMachine;
}
else if (targetObject.GetType() == typeof(State))
{
checkingState = targetObject as State;
}
else if (targetObject.GetType().IsSubclassOf(typeof(ExecutableNode)))
{
checkingExecutableNode = targetObject as ExecutableNode;
}
FieldInfo[] fields = targetObject.GetType().GetAllFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
for (int i = 0; i < fields.Length; i++)
{
FieldInfo field = fields[i];
if (field.HasAttribute(typeof(ReferenceAttribute)) || !field.IsSerialized())
{
continue;
}
object value = field.GetValue(targetObject);
if (field.FieldType.IsSubclassOf(typeof(FsmVariable)))
{
if (!field.HasAttribute(typeof(NotRequiredAttribute)) && (value == null || CheckForVariableError(value as FsmVariable, field)))
{
FsmError error = new FsmError(FsmError.ErrorType.RequiredField, checkingStateMachine, checkingState, checkingExecutableNode, value as FsmVariable, field);
if (!ContainsError(error))
{
errorList.Add(error);
}
}
}
else if (field.FieldType.IsSubclassOf(typeof(UnityEngine.Object)))
{
CheckForErrors(value as UnityEngine.Object);
}
else if (field.FieldType.IsArray)
{
var array = value as Array;
Type elementType = field.FieldType.GetElementType();
if (elementType.IsSubclassOf(typeof(UnityEngine.Object)))
{
foreach (UnityEngine.Object element in array)
{
CheckForErrors(element);
}
}
}
}
checkForErrors = false;
}
public FsmError(FsmError.ErrorType type,StateMachine stateMachine,State state,ExecutableNode executableNode,FsmVariable variable ,FieldInfo fieldInfo){
this.type = type;
this.variable = variable;
this.fieldInfo = fieldInfo;
this.stateMachine = stateMachine;
this.state = state;
this.executableNode = executableNode;
}
private static bool ContainsError(FsmError error)
{
foreach (FsmError mError in errorList)
{
if (mError.SameAs(error))
{
return(true);
}
}
return(false);
}
public bool SameAs(FsmError error){
if (type != error.Type) {
return false;
}
if (variable != error.Variable) {
return false;
}
return true;
}
public bool SameAs(FsmError error)
{
if (type != error.Type)
{
return(false);
}
if (variable != error.Variable)
{
return(false);
}
return(true);
}
public static void CheckForErrors(UnityEngine.Object targetObject){
if (targetObject == null) {
return;
}
if (targetObject.GetType ()==typeof(StateMachine)) {
checkingStateMachine = targetObject as StateMachine;
}else if(targetObject.GetType()==typeof(State)){
checkingState=targetObject as State;
} else if (targetObject.GetType ().IsSubclassOf (typeof(ExecutableNode))) {
checkingExecutableNode=targetObject as ExecutableNode;
}
FieldInfo[] fields = targetObject.GetType().GetAllFields (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
for (int i=0; i<fields.Length; i++) {
FieldInfo field=fields[i];
if(field.HasAttribute(typeof(ReferenceAttribute)) || !field.IsSerialized()){
continue;
}
object value=field.GetValue(targetObject);
if(field.FieldType.IsSubclassOf(typeof(FsmVariable))){
if(!field.HasAttribute(typeof(NotRequiredAttribute)) &&(value == null || CheckForVariableError(value as FsmVariable,field))){
FsmError error=new FsmError(FsmError.ErrorType.RequiredField,checkingStateMachine,checkingState,checkingExecutableNode,value as FsmVariable,field);
if(!ContainsError(error)){
errorList.Add(error);
}
}
}else if(field.FieldType.IsSubclassOf(typeof(UnityEngine.Object))){
CheckForErrors(value as UnityEngine.Object);
}else if(field.FieldType.IsArray){
var array = value as Array;
Type elementType = field.FieldType.GetElementType ();
if(elementType.IsSubclassOf(typeof(UnityEngine.Object))){
foreach(UnityEngine.Object element in array){
CheckForErrors(element);
}
}
}
}
checkForErrors = false;
}
private static bool ContainsError(FsmError error){
foreach (FsmError mError in errorList) {
if(mError.SameAs(error)){
return true;
}
}
return false;
}
private void OnGUI()
{
List <FsmError> errors = ErrorChecker.GetErrors();
if (selectedFsmErrors)
{
if (FsmEditor.instance != null)
{
errors = errors.FindAll(x => x.State.Parent == FsmEditor.Active).ToList();
}
else
{
errors.Clear();
}
}
//Toolbar
GUILayout.BeginHorizontal(EditorStyles.toolbar);
if (GUILayout.Button("Refresh", EditorStyles.toolbarButton))
{
ErrorChecker.CheckForErrors();
}
GUILayout.FlexibleSpace();
if (GUILayout.Button("Selected FSM Only", (selectedFsmErrors?(GUIStyle)"TE toolbarbutton" : EditorStyles.toolbarButton)))
{
selectedFsmErrors = !selectedFsmErrors;
ErrorChecker.CheckForErrors();
EditorPrefs.SetBool("SelectedFSMOnly", selectedFsmErrors);
}
GUILayout.EndHorizontal();
scroll = EditorGUILayout.BeginScrollView(scroll);
for (int i = 0; i < errors.Count; i++)
{
FsmError error = errors[i];
GUIStyle style = FsmEditorStyles.elementBackground;
if (i == index)
{
style = new GUIStyle("MeTransitionSelectHead")
{
stretchHeight = false,
};
style.overflow = new RectOffset(-1, -2, -2, 2);
}
GUILayout.BeginVertical(style);
GUILayout.Label(error.Type.ToString());
GUILayout.Label(error.State.Parent.Name + " : " + error.State.Name + " : " + error.ExecutableNode.name + (error.FieldInfo != null? " : " + error.FieldInfo.Name:""));
GUILayout.EndVertical();
Rect elementRect = new Rect(0, i * 19f * 2f, Screen.width, 19f * 2f);
Event ev = Event.current;
switch (ev.rawType)
{
case EventType.MouseDown:
if (elementRect.Contains(Event.current.mousePosition))
{
if (Event.current.button == 0)
{
index = i;
if (FsmEditor.instance == null)
{
FsmEditor.ShowWindow();
}
FsmEditor.SelectNode(error.State);
Event.current.Use();
}
}
break;
}
}
EditorGUILayout.EndScrollView();
}
public override void OnGUI(SerializedProperty property, GUIContent label)
{
if (property.objectReferenceValue == null)
{
CreateVariable(property);
}
if (property.objectReferenceValue == null)
{
return;
}
SerializedObject serializedObject = new SerializedObject(property.objectReferenceValue);
serializedObject.Update();
GUILayout.BeginHorizontal();
SerializedProperty nameProperty = serializedObject.FindProperty("name");
SerializedProperty valueProperty = serializedObject.FindProperty("value");
SerializedProperty sharedProperty = serializedObject.FindProperty("isShared");
if (EditorUtility.IsPersistent(property.objectReferenceValue) && fieldInfo.HasAttribute(typeof(SharedPersistentAttribute)) || fieldInfo.FieldType == typeof(FsmArray))
{
sharedProperty.boolValue = true;
}
Color color = GUI.backgroundColor;
FsmError error = ErrorChecker.GetError(property.objectReferenceValue);
if (error != null)
{
GUI.backgroundColor = Color.red;
}
int variableIndex = -1;
if (sharedProperty.boolValue)
{
variableIndex = DrawSharedVariable(label, nameProperty);
}
else
{
OnPropertyField(valueProperty, label);
}
GUI.backgroundColor = color;
if (DoSharedToggle(property))
{
DrawSharedToggle(sharedProperty);
}
GUILayout.EndHorizontal();
if (variableIndex == 0)
{
nameProperty.stringValue = "None";
Color color1 = GUI.backgroundColor;
GUI.backgroundColor = (EditorGUIUtility.isProSkin?new Color(0f, 0f, 0f, 0.6f):new Color(0f, 0f, 0f, 0.2f));
GUIStyle style = new GUIStyle("box");
style.normal.textColor = new Color(0f, 0f, 0f, 0.7f);
if (GUILayout.Button("Click to create a new variable [" + fieldInfo.FieldType.Name + "]", style, GUILayout.ExpandWidth(true)))
{
CreateVariable(property.objectReferenceValue.GetType(), fieldInfo.Name);
nameProperty.stringValue = fieldInfo.Name;
}
GUI.backgroundColor = color1;
}
serializedObject.ApplyModifiedProperties();
}
