public static Dictionary <string, object> SerializeTask(Task task, bool serializeChildren, ref List <UnityEngine.Object> unityObjects)
{
Dictionary <string, object> dictionary = new Dictionary <string, object>();
dictionary.Add("ObjectType", task.GetType());
dictionary.Add("NodeData", SerializeJSON.SerializeNodeData(task.NodeData));
dictionary.Add("ID", task.ID);
dictionary.Add("Name", task.FriendlyName);
dictionary.Add("Instant", task.IsInstant);
SerializeJSON.SerializeFields(task, ref dictionary, ref unityObjects);
if (serializeChildren && task is ParentTask)
{
ParentTask parentTask = task as ParentTask;
if (parentTask.Children != null && parentTask.Children.Count > 0)
{
Dictionary <string, object>[] array = new Dictionary <string, object> [parentTask.Children.Count];
for (int i = 0; i < parentTask.Children.Count; i++)
{
array[i] = SerializeJSON.SerializeTask(parentTask.Children[i], serializeChildren, ref unityObjects);
}
dictionary.Add("Children", array);
}
}
return(dictionary);
}
public static void Save(BehaviorSource behaviorSource)
{
behaviorSource.CheckForSerialization(false, null);
SerializeJSON.taskSerializationData = new TaskSerializationData();
SerializeJSON.fieldSerializationData = SerializeJSON.taskSerializationData.fieldSerializationData;
Dictionary <string, object> dictionary = new Dictionary <string, object>();
if (behaviorSource.EntryTask != null)
{
dictionary.Add("EntryTask", SerializeJSON.SerializeTask(behaviorSource.EntryTask, true, ref SerializeJSON.fieldSerializationData.unityObjects));
}
if (behaviorSource.RootTask != null)
{
dictionary.Add("RootTask", SerializeJSON.SerializeTask(behaviorSource.RootTask, true, ref SerializeJSON.fieldSerializationData.unityObjects));
}
if (behaviorSource.DetachedTasks != null && behaviorSource.DetachedTasks.Count > 0)
{
Dictionary <string, object>[] array = new Dictionary <string, object> [behaviorSource.DetachedTasks.Count];
for (int i = 0; i < behaviorSource.DetachedTasks.Count; i++)
{
array[i] = SerializeJSON.SerializeTask(behaviorSource.DetachedTasks[i], true, ref SerializeJSON.fieldSerializationData.unityObjects);
}
dictionary.Add("DetachedTasks", array);
}
if (behaviorSource.Variables != null && behaviorSource.Variables.Count > 0)
{
dictionary.Add("Variables", SerializeJSON.SerializeVariables(behaviorSource.Variables, ref SerializeJSON.fieldSerializationData.unityObjects));
}
SerializeJSON.taskSerializationData.JSONSerialization = MiniJSON.Serialize(dictionary);
behaviorSource.TaskData = SerializeJSON.taskSerializationData;
if (behaviorSource.Owner != null)
{
EditorUtility.SetDirty(behaviorSource.Owner.GetObject());
}
}
private static Dictionary <string, object> SerializeVariable(SharedVariable sharedVariable, ref List <UnityEngine.Object> unityObjects)
{
if (sharedVariable == null)
{
return(null);
}
Dictionary <string, object> dictionary = new Dictionary <string, object>();
dictionary.Add("Type", sharedVariable.GetType());
dictionary.Add("Name", sharedVariable.Name);
if (sharedVariable.IsShared)
{
dictionary.Add("IsShared", sharedVariable.IsShared);
}
if (sharedVariable.IsGlobal)
{
dictionary.Add("IsGlobal", sharedVariable.IsGlobal);
}
if (sharedVariable.NetworkSync)
{
dictionary.Add("NetworkSync", sharedVariable.NetworkSync);
}
if (!string.IsNullOrEmpty(sharedVariable.PropertyMapping))
{
dictionary.Add("PropertyMapping", sharedVariable.PropertyMapping);
if (!object.Equals(sharedVariable.PropertyMappingOwner, null))
{
dictionary.Add("PropertyMappingOwner", unityObjects.Count);
unityObjects.Add(sharedVariable.PropertyMappingOwner);
}
}
SerializeJSON.SerializeFields(sharedVariable, ref dictionary, ref unityObjects);
return(dictionary);
}
public static TaskSerializer CopySerialized(Task task)
{
TaskSerializer taskSerializer = new TaskSerializer();
taskSerializer.offset = (task.NodeData.NodeDesigner as NodeDesigner).GetAbsolutePosition() + new Vector2(10f, 10f);
taskSerializer.unityObjects = new List <UnityEngine.Object>();
taskSerializer.serialization = MiniJSON.Serialize(SerializeJSON.SerializeTask(task, false, ref taskSerializer.unityObjects));
return(taskSerializer);
}
private static Dictionary <string, object>[] SerializeVariables(List <SharedVariable> variables, ref List <UnityEngine.Object> unityObjects)
{
Dictionary <string, object>[] array = new Dictionary <string, object> [variables.Count];
for (int i = 0; i < variables.Count; i++)
{
array[i] = SerializeJSON.SerializeVariable(variables[i], ref unityObjects);
}
return(array);
}
private void SerializeVariables()
{
if (mVariableSource == null)
{
mVariableSource = GlobalVariables.Instance;
}
if (BehaviorDesignerPreferences.GetBool(BDPreferences.BinarySerialization))
{
BinarySerialization.Save(mVariableSource);
}
else
{
SerializeJSON.Save(mVariableSource);
}
}
public static void Save(GlobalVariables variables)
{
if (variables == null)
{
return;
}
SerializeJSON.variableSerializationData = new VariableSerializationData();
SerializeJSON.fieldSerializationData = SerializeJSON.variableSerializationData.fieldSerializationData;
Dictionary <string, object> dictionary = new Dictionary <string, object>();
dictionary.Add("Variables", SerializeJSON.SerializeVariables(variables.Variables, ref SerializeJSON.fieldSerializationData.unityObjects));
SerializeJSON.variableSerializationData.JSONSerialization = MiniJSON.Serialize(dictionary);
variables.VariableData = SerializeJSON.variableSerializationData;
EditorUtility.SetDirty(variables);
}
public static bool DrawInspectorGUI(BehaviorSource behaviorSource, bool fromInspector, ref bool showVariables)
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
EditorGUILayout.LabelField("Behavior Name", new GUILayoutOption[]
{
GUILayout.Width(120f)
});
behaviorSource.behaviorName = EditorGUILayout.TextField(behaviorSource.behaviorName, new GUILayoutOption[0]);
if (fromInspector && GUILayout.Button("Open", new GUILayoutOption[0]))
{
BehaviorDesignerWindow.ShowWindow();
BehaviorDesignerWindow.instance.LoadBehavior(behaviorSource, false, true);
}
GUILayout.EndHorizontal();
EditorGUILayout.LabelField("Behavior Description", new GUILayoutOption[0]);
behaviorSource.behaviorDescription = EditorGUILayout.TextArea(behaviorSource.behaviorDescription, new GUILayoutOption[]
{
GUILayout.Height(48f)
});
if (fromInspector && (showVariables = EditorGUILayout.Foldout(showVariables, "Variables")))
{
List <SharedVariable> allVariables = behaviorSource.GetAllVariables();
if (allVariables != null && VariableInspector.DrawAllVariables(false, behaviorSource, ref allVariables, false, ref ExternalBehaviorInspector.variablePosition, ref ExternalBehaviorInspector.selectedVariableIndex, ref ExternalBehaviorInspector.selectedVariableName, ref ExternalBehaviorInspector.selectedVariableTypeIndex, true, false))
{
if (BehaviorDesignerPreferences.GetBool(BDPreferences.BinarySerialization))
{
BinarySerialization.Save(behaviorSource);
}
else
{
SerializeJSON.Save(behaviorSource);
}
}
}
return(EditorGUI.EndChangeCheck());
}
private static void PropertySelected(object selected)
{
bool flag = false;
if (!Application.isPlaying && VariableInspector.mPropertyMappingBehaviorSource.Owner.GetObject() is Behavior && (VariableInspector.mPropertyMappingBehaviorSource.Owner.GetObject() as Behavior).ExternalBehavior != null)
{
VariableInspector.mPropertyMappingBehaviorSource.CheckForSerialization(true, null);
VariableInspector.mPropertyMappingVariable = VariableInspector.mPropertyMappingBehaviorSource.GetVariable(VariableInspector.mPropertyMappingVariable.Name);
flag = true;
}
VariableInspector.SelectedPropertyMapping selectedPropertyMapping = selected as VariableInspector.SelectedPropertyMapping;
if (selectedPropertyMapping.Property.Equals("None"))
{
VariableInspector.mPropertyMappingVariable.PropertyMapping = string.Empty;
VariableInspector.mPropertyMappingVariable.PropertyMappingOwner = null;
}
else
{
VariableInspector.mPropertyMappingVariable.PropertyMapping = selectedPropertyMapping.Property;
VariableInspector.mPropertyMappingVariable.PropertyMappingOwner = selectedPropertyMapping.GameObject;
}
if (BehaviorDesignerPreferences.GetBool(BDPreferences.BinarySerialization))
{
BinarySerialization.Save(VariableInspector.mPropertyMappingBehaviorSource);
}
else
{
SerializeJSON.Save(VariableInspector.mPropertyMappingBehaviorSource);
}
if (flag)
{
ExternalBehavior externalBehavior = (VariableInspector.mPropertyMappingBehaviorSource.Owner as Behavior).ExternalBehavior;
externalBehavior.BehaviorSource.Owner = externalBehavior;
externalBehavior.BehaviorSource.CheckForSerialization(true, VariableInspector.mPropertyMappingBehaviorSource);
}
}
public static bool DrawVariables(IVariableSource variableSource, bool enabled, BehaviorSource behaviorSource, ref string variableName, ref bool focusNameField, ref int variableTypeIndex, ref Vector2 scrollPosition, ref List <float> variablePosition, ref float variableStartPosition, ref int selectedVariableIndex, ref string selectedVariableName, ref int selectedVariableTypeIndex)
{
scrollPosition = GUILayout.BeginScrollView(scrollPosition, new GUILayoutOption[0]);
GUI.enabled = enabled;
bool flag = false;
bool flag2 = false;
List <SharedVariable> list = (variableSource == null) ? null : variableSource.GetAllVariables();
if (!Application.isPlaying && behaviorSource != null && behaviorSource.Owner is Behavior)
{
Behavior behavior = behaviorSource.Owner as Behavior;
if (behavior.ExternalBehavior != null)
{
flag2 = true;
GUI.enabled = false;
BehaviorSource behaviorSource2 = behavior.GetBehaviorSource();
behaviorSource2.CheckForSerialization(true, null);
if (VariableInspector.DrawHeader(behaviorSource2, false, ref variableStartPosition, ref variableName, ref focusNameField, ref variableTypeIndex, ref selectedVariableIndex, ref selectedVariableName, ref selectedVariableTypeIndex))
{
flag = true;
}
GUI.enabled = enabled;
if (VariableInspector.SyncVariables(behaviorSource2, list))
{
flag = true;
}
List <SharedVariable> allVariables = behaviorSource2.GetAllVariables();
if (VariableInspector.DrawAllVariables(true, behaviorSource, ref allVariables, false, ref variablePosition, ref selectedVariableIndex, ref selectedVariableName, ref selectedVariableTypeIndex, false, true))
{
flag = true;
}
if (flag)
{
if (BehaviorDesignerPreferences.GetBool(BDPreferences.BinarySerialization))
{
BinarySerialization.Save(behaviorSource2);
}
else
{
SerializeJSON.Save(behaviorSource2);
}
}
ExternalBehavior externalBehavior = (behaviorSource.Owner as Behavior).ExternalBehavior;
externalBehavior.BehaviorSource.Owner = externalBehavior;
externalBehavior.BehaviorSource.CheckForSerialization(true, behaviorSource);
}
}
if (!flag2)
{
if (VariableInspector.DrawHeader(variableSource, behaviorSource == null, ref variableStartPosition, ref variableName, ref focusNameField, ref variableTypeIndex, ref selectedVariableIndex, ref selectedVariableName, ref selectedVariableTypeIndex))
{
flag = true;
}
list = ((variableSource == null) ? null : variableSource.GetAllVariables());
if (list != null && list.Count > 0)
{
GUI.enabled = (enabled && !flag2);
if (VariableInspector.DrawAllVariables(true, variableSource, ref list, true, ref variablePosition, ref selectedVariableIndex, ref selectedVariableName, ref selectedVariableTypeIndex, true, true))
{
flag = true;
}
}
if (flag && variableSource != null)
{
variableSource.SetAllVariables(list);
}
}
GUI.enabled = true;
GUILayout.EndScrollView();
return(flag);
}
public static bool DrawInspectorGUI(Behavior behavior, SerializedObject serializedObject, bool fromInspector, ref bool externalModification, ref bool showOptions, ref bool showVariables)
{
EditorGUI.BeginChangeCheck();
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
EditorGUILayout.LabelField("Behavior Name", new GUILayoutOption[]
{
GUILayout.Width(120f)
});
behavior.GetBehaviorSource().behaviorName = EditorGUILayout.TextField(behavior.GetBehaviorSource().behaviorName, new GUILayoutOption[0]);
if (fromInspector && GUILayout.Button("Open", new GUILayoutOption[0]))
{
BehaviorDesignerWindow.ShowWindow();
BehaviorDesignerWindow.instance.LoadBehavior(behavior.GetBehaviorSource(), false, true);
}
GUILayout.EndHorizontal();
EditorGUILayout.LabelField("Behavior Description", new GUILayoutOption[0]);
behavior.GetBehaviorSource().behaviorDescription = EditorGUILayout.TextArea(behavior.GetBehaviorSource().behaviorDescription, BehaviorDesignerUtility.TaskInspectorCommentGUIStyle, new GUILayoutOption[]
{
GUILayout.Height(48f)
});
serializedObject.Update();
GUI.enabled = (PrefabUtility.GetPrefabType(behavior) != PrefabType.PrefabInstance || BehaviorDesignerPreferences.GetBool(BDPreferences.EditablePrefabInstances));
SerializedProperty serializedProperty = serializedObject.FindProperty("externalBehavior");
ExternalBehavior externalBehavior = serializedProperty.objectReferenceValue as ExternalBehavior;
EditorGUILayout.PropertyField(serializedProperty, true, new GUILayoutOption[0]);
serializedObject.ApplyModifiedProperties();
if ((!object.ReferenceEquals(behavior.ExternalBehavior, null) && !behavior.ExternalBehavior.Equals(externalBehavior)) || (!object.ReferenceEquals(externalBehavior, null) && !externalBehavior.Equals(behavior.ExternalBehavior)))
{
if (!object.ReferenceEquals(behavior.ExternalBehavior, null))
{
behavior.ExternalBehavior.BehaviorSource.Owner = behavior.ExternalBehavior;
behavior.ExternalBehavior.BehaviorSource.CheckForSerialization(true, behavior.GetBehaviorSource());
}
else
{
behavior.GetBehaviorSource().EntryTask = null;
behavior.GetBehaviorSource().RootTask = null;
behavior.GetBehaviorSource().DetachedTasks = null;
behavior.GetBehaviorSource().Variables = null;
behavior.GetBehaviorSource().CheckForSerialization(true, null);
behavior.GetBehaviorSource().Variables = null;
if (BehaviorDesignerPreferences.GetBool(BDPreferences.BinarySerialization))
{
BinarySerialization.Save(behavior.GetBehaviorSource());
}
else
{
SerializeJSON.Save(behavior.GetBehaviorSource());
}
}
externalModification = true;
}
GUI.enabled = true;
serializedProperty = serializedObject.FindProperty("group");
EditorGUILayout.PropertyField(serializedProperty, true, new GUILayoutOption[0]);
if (fromInspector && (showVariables = EditorGUILayout.Foldout(showVariables, "Variables")))
{
EditorGUI.indentLevel++;
List <SharedVariable> allVariables = behavior.GetAllVariables();
BehaviorSource behaviorSource = behavior.GetBehaviorSource();
bool flag = false;
if (!Application.isPlaying && behavior.ExternalBehavior != null)
{
behaviorSource.CheckForSerialization(true, null);
flag = true;
}
bool flag2 = false;
if (VariableInspector.SyncVariables(behaviorSource, allVariables))
{
flag2 = true;
}
if (allVariables != null && allVariables.Count > 0)
{
List <SharedVariable> allVariables2 = behaviorSource.GetAllVariables();
if (VariableInspector.DrawAllVariables(false, behaviorSource, ref allVariables2, false, ref BehaviorInspector.variablePosition, ref BehaviorInspector.selectedVariableIndex, ref BehaviorInspector.selectedVariableName, ref BehaviorInspector.selectedVariableTypeIndex, false, true))
{
flag2 = true;
}
}
else
{
EditorGUILayout.LabelField("There are no variables to display", new GUILayoutOption[0]);
}
if (flag)
{
ExternalBehavior externalBehavior2 = (behaviorSource.Owner as Behavior).ExternalBehavior;
externalBehavior2.BehaviorSource.Owner = externalBehavior2;
externalBehavior2.BehaviorSource.CheckForSerialization(true, behaviorSource);
}
if (flag2)
{
if (BehaviorDesignerPreferences.GetBool(BDPreferences.BinarySerialization))
{
BinarySerialization.Save(behaviorSource);
}
else
{
SerializeJSON.Save(behaviorSource);
}
}
EditorGUI.indentLevel--;
}
if (!fromInspector || (showOptions = EditorGUILayout.Foldout(showOptions, "Options")))
{
if (fromInspector)
{
EditorGUI.indentLevel++;
}
serializedProperty = serializedObject.FindProperty("startWhenEnabled");
EditorGUILayout.PropertyField(serializedProperty, true, new GUILayoutOption[0]);
serializedProperty = serializedObject.FindProperty("pauseWhenDisabled");
EditorGUILayout.PropertyField(serializedProperty, true, new GUILayoutOption[0]);
serializedProperty = serializedObject.FindProperty("restartWhenComplete");
EditorGUILayout.PropertyField(serializedProperty, true, new GUILayoutOption[0]);
serializedProperty = serializedObject.FindProperty("resetValuesOnRestart");
EditorGUILayout.PropertyField(serializedProperty, true, new GUILayoutOption[0]);
serializedProperty = serializedObject.FindProperty("logTaskChanges");
EditorGUILayout.PropertyField(serializedProperty, true, new GUILayoutOption[0]);
if (fromInspector)
{
EditorGUI.indentLevel--;
}
}
if (EditorGUI.EndChangeCheck())
{
serializedObject.ApplyModifiedProperties();
return(true);
}
return(false);
}
private static void SerializeFields(object obj, ref Dictionary <string, object> dict, ref List <UnityEngine.Object> unityObjects)
{
FieldInfo[] allFields = TaskUtility.GetAllFields(obj.GetType());
for (int i = 0; i < allFields.Length; i++)
{
if (!BehaviorDesignerUtility.HasAttribute(allFields[i], typeof(NonSerializedAttribute)) && ((!allFields[i].IsPrivate && !allFields[i].IsFamily) || BehaviorDesignerUtility.HasAttribute(allFields[i], typeof(SerializeField))) && (!(obj is ParentTask) || !allFields[i].Name.Equals("children")))
{
if (allFields[i].GetValue(obj) != null)
{
if (typeof(IList).IsAssignableFrom(allFields[i].FieldType))
{
IList list = allFields[i].GetValue(obj) as IList;
if (list != null)
{
List <object> list2 = new List <object>();
for (int j = 0; j < list.Count; j++)
{
if (list[j] == null || object.ReferenceEquals(list[j], null) || list[j].Equals(null))
{
list2.Add(-1);
}
else
{
Type type = list[j].GetType();
if (list[j] is Task)
{
Task task = list[j] as Task;
list2.Add(task.ID);
}
else if (list[j] is SharedVariable)
{
list2.Add(SerializeJSON.SerializeVariable(list[j] as SharedVariable, ref unityObjects));
}
else if (list[j] is UnityEngine.Object)
{
UnityEngine.Object @object = list[j] as UnityEngine.Object;
if (!object.ReferenceEquals(@object, null) && @object != null)
{
list2.Add(unityObjects.Count);
unityObjects.Add(@object);
}
}
else if (type.Equals(typeof(LayerMask)))
{
list2.Add(((LayerMask)list[j]).value);
}
else if (type.IsPrimitive || type.IsEnum || type.Equals(typeof(string)) || type.Equals(typeof(Vector2)) || type.Equals(typeof(Vector3)) || type.Equals(typeof(Vector4)) || type.Equals(typeof(Quaternion)) || type.Equals(typeof(Matrix4x4)) || type.Equals(typeof(Color)) || type.Equals(typeof(Rect)))
{
list2.Add(list[j]);
}
else
{
Dictionary <string, object> item = new Dictionary <string, object>();
SerializeJSON.SerializeFields(list[j], ref item, ref unityObjects);
list2.Add(item);
}
}
}
if (list2 != null)
{
dict.Add(allFields[i].FieldType + "," + allFields[i].Name, list2);
}
}
}
else if (allFields[i].FieldType.Equals(typeof(Task)) || allFields[i].FieldType.IsSubclassOf(typeof(Task)))
{
Task task2 = allFields[i].GetValue(obj) as Task;
if (task2 != null)
{
if (BehaviorDesignerUtility.HasAttribute(allFields[i], typeof(InspectTaskAttribute)))
{
Dictionary <string, object> dictionary = new Dictionary <string, object>();
dictionary.Add("ObjectType", task2.GetType());
SerializeJSON.SerializeFields(task2, ref dictionary, ref unityObjects);
dict.Add(allFields[i].Name, dictionary);
}
else
{
dict.Add(allFields[i].FieldType + "," + allFields[i].Name, task2.ID);
}
}
}
else if (allFields[i].FieldType.Equals(typeof(SharedVariable)) || allFields[i].FieldType.IsSubclassOf(typeof(SharedVariable)))
{
dict.Add(allFields[i].FieldType + "," + allFields[i].Name, SerializeJSON.SerializeVariable(allFields[i].GetValue(obj) as SharedVariable, ref unityObjects));
}
else if (allFields[i].FieldType.Equals(typeof(UnityEngine.Object)) || allFields[i].FieldType.IsSubclassOf(typeof(UnityEngine.Object)))
{
UnityEngine.Object object2 = allFields[i].GetValue(obj) as UnityEngine.Object;
if (!object.ReferenceEquals(object2, null) && object2 != null)
{
dict.Add(allFields[i].FieldType + "," + allFields[i].Name, unityObjects.Count);
unityObjects.Add(object2);
}
}
else if (allFields[i].FieldType.Equals(typeof(LayerMask)))
{
dict.Add(allFields[i].FieldType + "," + allFields[i].Name, ((LayerMask)allFields[i].GetValue(obj)).value);
}
else if (allFields[i].FieldType.IsPrimitive || allFields[i].FieldType.IsEnum || allFields[i].FieldType.Equals(typeof(string)) || allFields[i].FieldType.Equals(typeof(Vector2)) || allFields[i].FieldType.Equals(typeof(Vector3)) || allFields[i].FieldType.Equals(typeof(Vector4)) || allFields[i].FieldType.Equals(typeof(Quaternion)) || allFields[i].FieldType.Equals(typeof(Matrix4x4)) || allFields[i].FieldType.Equals(typeof(Color)) || allFields[i].FieldType.Equals(typeof(Rect)))
{
dict.Add(allFields[i].FieldType + "," + allFields[i].Name, allFields[i].GetValue(obj));
}
else if (allFields[i].FieldType.Equals(typeof(AnimationCurve)))
{
AnimationCurve animationCurve = allFields[i].GetValue(obj) as AnimationCurve;
Dictionary <string, object> dictionary2 = new Dictionary <string, object>();
if (animationCurve.keys != null)
{
Keyframe[] keys = animationCurve.keys;
List <List <object> > list3 = new List <List <object> >();
for (int k = 0; k < keys.Length; k++)
{
list3.Add(new List <object>
{
keys[k].time,
keys[k].value,
keys[k].inTangent,
keys[k].outTangent,
keys[k].tangentMode
});
}
dictionary2.Add("Keys", list3);
}
dictionary2.Add("PreWrapMode", animationCurve.preWrapMode);
dictionary2.Add("PostWrapMode", animationCurve.postWrapMode);
dict.Add(allFields[i].FieldType + "," + allFields[i].Name, dictionary2);
}
else
{
Dictionary <string, object> value = new Dictionary <string, object>();
SerializeJSON.SerializeFields(allFields[i].GetValue(obj), ref value, ref unityObjects);
dict.Add(allFields[i].FieldType + "," + allFields[i].Name, value);
}
}
}
}
}
