private static SharedVariable BytesToSharedVariable(FieldSerializationData fieldSerializationData, Dictionary <string, int> fieldIndexMap, byte[] bytes, int dataPosition, IVariableSource variableSource, bool fromField, string namePrefix)
{
SharedVariable sharedVariable = null;
string text = (string)LoadField(fieldSerializationData, fieldIndexMap, typeof(string), namePrefix + "Type", null);
if (string.IsNullOrEmpty(text))
{
return(null);
}
string name = (string)LoadField(fieldSerializationData, fieldIndexMap, typeof(string), namePrefix + "Name", null);
bool flag = Convert.ToBoolean(LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), namePrefix + "IsShared", null, null, null));
bool flag2 = Convert.ToBoolean(LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), namePrefix + "IsGlobal", null, null, null));
if (flag && fromField)
{
if (!flag2)
{
sharedVariable = variableSource.GetVariable(name);
}
else
{
if (globalVariables == null)
{
globalVariables = GlobalVariables.Instance;
}
if (globalVariables != null)
{
sharedVariable = globalVariables.GetVariable(name);
}
}
}
Type typeWithinAssembly = TaskUtility.GetTypeWithinAssembly(text);
if (typeWithinAssembly == null)
{
return(null);
}
bool flag3 = true;
if (sharedVariable == null || !(flag3 = sharedVariable.GetType().Equals(typeWithinAssembly)))
{
sharedVariable = (TaskUtility.CreateInstance(typeWithinAssembly) as SharedVariable);
sharedVariable.Name = name;
sharedVariable.IsShared = flag;
sharedVariable.IsGlobal = flag2;
sharedVariable.NetworkSync = Convert.ToBoolean(LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), namePrefix + "NetworkSync", null));
if (!flag2)
{
sharedVariable.PropertyMapping = (string)LoadField(fieldSerializationData, fieldIndexMap, typeof(string), namePrefix + "PropertyMapping", null);
sharedVariable.PropertyMappingOwner = (GameObject)LoadField(fieldSerializationData, fieldIndexMap, typeof(GameObject), namePrefix + "PropertyMappingOwner", null);
sharedVariable.InitializePropertyMapping(variableSource as BehaviorSource);
}
if (!flag3)
{
sharedVariable.IsShared = true;
}
LoadFields(fieldSerializationData, fieldIndexMap, sharedVariable, namePrefix, variableSource);
}
return(sharedVariable);
}
public static void Save(BehaviorSource behaviorSource)
{
BinarySerialization.fieldIndex = 0;
BinarySerialization.taskSerializationData = new TaskSerializationData();
BinarySerialization.fieldSerializationData = BinarySerialization.taskSerializationData.fieldSerializationData;
if (behaviorSource.Variables != null)
{
for (int i = 0; i < behaviorSource.Variables.Count; i++)
{
BinarySerialization.taskSerializationData.variableStartIndex.Add(BinarySerialization.fieldSerializationData.startIndex.Count);
BinarySerialization.SaveSharedVariable(behaviorSource.Variables[i], string.Empty);
}
}
if (!object.ReferenceEquals(behaviorSource.EntryTask, null))
{
BinarySerialization.SaveTask(behaviorSource.EntryTask, -1);
}
if (!object.ReferenceEquals(behaviorSource.RootTask, null))
{
BinarySerialization.SaveTask(behaviorSource.RootTask, 0);
}
if (behaviorSource.DetachedTasks != null)
{
for (int j = 0; j < behaviorSource.DetachedTasks.Count; j++)
{
BinarySerialization.SaveTask(behaviorSource.DetachedTasks[j], -1);
}
}
behaviorSource.TaskData = BinarySerialization.taskSerializationData;
if (behaviorSource.Owner != null)
{
EditorUtility.SetDirty(behaviorSource.Owner.GetObject());
}
}
private static void LoadNodeData(FieldSerializationData fieldSerializationData, Dictionary <string, int> fieldIndexMap, Task task)
{
NodeData nodeData = new NodeData();
nodeData.Offset = (Vector2)LoadField(fieldSerializationData, fieldIndexMap, typeof(Vector2), "NodeDataOffset", null, null, null);
nodeData.Comment = (string)LoadField(fieldSerializationData, fieldIndexMap, typeof(string), "NodeDataComment", null, null, null);
nodeData.IsBreakpoint = (bool)LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), "NodeDataIsBreakpoint", null, null, null);
nodeData.Disabled = (bool)LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), "NodeDataDisabled", null, null, null);
nodeData.Collapsed = (bool)LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), "NodeDataCollapsed", null, null, null);
object obj = LoadField(fieldSerializationData, fieldIndexMap, typeof(int), "NodeDataColorIndex", null, null, null);
if (obj != null)
{
nodeData.ColorIndex = (int)obj;
}
obj = LoadField(fieldSerializationData, fieldIndexMap, typeof(List <string>), "NodeDataWatchedFields", null, null, null);
if (obj != null)
{
nodeData.WatchedFieldNames = new List <string>();
nodeData.WatchedFields = new List <FieldInfo>();
IList list = obj as IList;
for (int i = 0; i < list.Count; i++)
{
FieldInfo field = task.GetType().GetField((string)list[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
nodeData.WatchedFieldNames.Add(field.Name);
nodeData.WatchedFields.Add(field);
}
}
}
task.NodeData = nodeData;
}
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 UnityEngine.Object IndexToUnityObject(int index, FieldSerializationData activeFieldSerializationData)
{
if (index < 0 || index >= activeFieldSerializationData.unityObjects.Count)
{
return(null);
}
return(activeFieldSerializationData.unityObjects[index]);
}
private static void LoadFields(FieldSerializationData fieldSerializationData, Dictionary <string, int> fieldIndexMap, object obj, string namePrefix, IVariableSource variableSource)
{
FieldInfo[] allFields = TaskUtility.GetAllFields(obj.GetType());
for (int i = 0; i < allFields.Length; i++)
{
if (!TaskUtility.HasAttribute(allFields[i], typeof(NonSerializedAttribute)) && ((!allFields[i].IsPrivate && !allFields[i].IsFamily) || TaskUtility.HasAttribute(allFields[i], typeof(SerializeField))) && (!(obj is ParentTask) || !allFields[i].Name.Equals("children")))
{
object obj2 = LoadField(fieldSerializationData, fieldIndexMap, allFields[i].FieldType, namePrefix + allFields[i].Name, variableSource, obj, allFields[i]);
if (obj2 != null && !ReferenceEquals(obj2, null) && !obj2.Equals(null))
{
allFields[i].SetValue(obj, obj2);
}
}
}
}
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 void Save(GlobalVariables globalVariables)
{
if (globalVariables == null)
{
return;
}
BinarySerialization.fieldIndex = 0;
globalVariables.VariableData = new VariableSerializationData();
if (globalVariables.Variables == null || globalVariables.Variables.Count == 0)
{
return;
}
BinarySerialization.fieldSerializationData = globalVariables.VariableData.fieldSerializationData;
for (int i = 0; i < globalVariables.Variables.Count; i++)
{
globalVariables.VariableData.variableStartIndex.Add(BinarySerialization.fieldSerializationData.startIndex.Count);
BinarySerialization.SaveSharedVariable(globalVariables.Variables[i], string.Empty);
}
EditorUtility.SetDirty(globalVariables);
}
private static int GetFieldSize(FieldSerializationData fieldSerializationData, int fieldIndex)
{
return(((fieldIndex + 1 >= fieldSerializationData.dataPosition.Count) ? fieldSerializationData.byteData.Count : fieldSerializationData.dataPosition[fieldIndex + 1]) - fieldSerializationData.dataPosition[fieldIndex]);
}
private static object LoadField(FieldSerializationData fieldSerializationData, Dictionary <string, int> fieldIndexMap, Type fieldType, string fieldName, IVariableSource variableSource, object obj = null, FieldInfo fieldInfo = null)
{
string text = fieldType.Name + fieldName;
int num;
if (fieldIndexMap.TryGetValue(text, out num))
{
object obj2 = null;
if (typeof(IList).IsAssignableFrom(fieldType))
{
int num2 = BytesToInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
if (fieldType.IsArray)
{
Type elementType = fieldType.GetElementType();
if (elementType == null)
{
return(null);
}
Array array = Array.CreateInstance(elementType, num2);
for (int i = 0; i < num2; i++)
{
object obj3 = LoadField(fieldSerializationData, fieldIndexMap, elementType, text + i, variableSource, obj, fieldInfo);
array.SetValue((!(obj3 is null) && !obj3.Equals(null)) ? obj3 : null, i);
}
obj2 = array;
}
else
{
Type type = fieldType;
while (!type.IsGenericType)
{
type = type.BaseType;
}
Type type2 = type.GetGenericArguments()[0];
IList list;
if (fieldType.IsGenericType)
{
list = (TaskUtility.CreateInstance(typeof(List <>).MakeGenericType(new Type[]
{
type2
})) as IList);
}
else
{
list = (TaskUtility.CreateInstance(fieldType) as IList);
}
for (int j = 0; j < num2; j++)
{
object obj4 = LoadField(fieldSerializationData, fieldIndexMap, type2, text + j, variableSource, obj, fieldInfo);
list.Add((!ReferenceEquals(obj4, null) && !obj4.Equals(null)) ? obj4 : null);
}
obj2 = list;
}
}
else if (typeof(Task).IsAssignableFrom(fieldType))
{
if (fieldInfo != null && TaskUtility.HasAttribute(fieldInfo, typeof(InspectTaskAttribute)))
{
string text2 = BytesToString(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num], GetFieldSize(fieldSerializationData, num));
if (!string.IsNullOrEmpty(text2))
{
Type typeWithinAssembly = TaskUtility.GetTypeWithinAssembly(text2);
if (typeWithinAssembly != null)
{
obj2 = TaskUtility.CreateInstance(typeWithinAssembly);
LoadFields(fieldSerializationData, fieldIndexMap, obj2, text, variableSource);
}
}
}
else
{
if (taskIDs == null)
{
taskIDs = new Dictionary <ObjectFieldMap, List <int> >(new ObjectFieldMapComparer());
}
int item = BytesToInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
ObjectFieldMap key = new ObjectFieldMap(obj, fieldInfo);
if (taskIDs.ContainsKey(key))
{
taskIDs[key].Add(item);
}
else
{
List <int> list2 = new List <int>();
list2.Add(item);
taskIDs.Add(key, list2);
}
}
}
else if (typeof(SharedVariable).IsAssignableFrom(fieldType))
{
obj2 = BytesToSharedVariable(fieldSerializationData, fieldIndexMap, fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num], variableSource, true, text);
}
else if (typeof(UnityEngine.Object).IsAssignableFrom(fieldType))
{
int index = BytesToInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
obj2 = IndexToUnityObject(index, fieldSerializationData);
}
else if (fieldType.Equals(typeof(int)) || fieldType.IsEnum)
{
obj2 = BytesToInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(uint)))
{
obj2 = BytesToUInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(float)))
{
obj2 = BytesToFloat(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(double)))
{
obj2 = BytesToDouble(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(long)))
{
obj2 = BytesToLong(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(bool)))
{
obj2 = BytesToBool(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(string)))
{
obj2 = BytesToString(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num], BinaryDeserialization.GetFieldSize(fieldSerializationData, num));
}
else if (fieldType.Equals(typeof(byte)))
{
obj2 = BytesToByte(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Vector2)))
{
obj2 = BytesToVector2(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Vector3)))
{
obj2 = BytesToVector3(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Vector4)))
{
obj2 = BytesToVector4(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Quaternion)))
{
obj2 = BytesToQuaternion(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Color)))
{
obj2 = BytesToColor(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Rect)))
{
obj2 = BytesToRect(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(Matrix4x4)))
{
obj2 = BytesToMatrix4x4(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(AnimationCurve)))
{
obj2 = BytesToAnimationCurve(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.Equals(typeof(LayerMask)))
{
obj2 = BytesToLayerMask(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[num]);
}
else if (fieldType.IsClass || (fieldType.IsValueType && !fieldType.IsPrimitive))
{
obj2 = TaskUtility.CreateInstance(fieldType);
LoadFields(fieldSerializationData, fieldIndexMap, obj2, text, variableSource);
return(obj2);
}
return(obj2);
}
if (typeof(SharedVariable).IsAssignableFrom(fieldType))
{
Type type3 = TaskUtility.SharedVariableToConcreteType(fieldType);
if (type3 == null)
{
return(null);
}
text = type3.Name + fieldName;
if (fieldIndexMap.ContainsKey(text))
{
SharedVariable sharedVariable = TaskUtility.CreateInstance(fieldType) as SharedVariable;
sharedVariable.SetValue(LoadField(fieldSerializationData, fieldIndexMap, type3, fieldName, variableSource, null, null));
return(sharedVariable);
}
}
if (typeof(SharedVariable).IsAssignableFrom(fieldType))
{
return(TaskUtility.CreateInstance(fieldType));
}
return(null);
}
private static void LoadTask(TaskSerializationData taskSerializationData, FieldSerializationData fieldSerializationData, ref List <Task> taskList, ref BehaviorSource behaviorSource)
{
int count = taskList.Count;
Type type = TaskUtility.GetTypeWithinAssembly(taskSerializationData.types[count]);
if (type == null)
{
bool flag = false;
for (int i = 0; i < taskSerializationData.parentIndex.Count; i++)
{
if (count == taskSerializationData.parentIndex[i])
{
flag = true;
break;
}
}
if (flag)
{
type = typeof(UnknownParentTask);
}
else
{
type = typeof(UnknownTask);
}
}
Task task = TaskUtility.CreateInstance(type) as Task;
task.Owner = (behaviorSource.Owner.GetObject() as Behavior);
taskList.Add(task);
int num = taskSerializationData.startIndex[count];
int num2;
if (count + 1 < taskSerializationData.startIndex.Count)
{
num2 = taskSerializationData.startIndex[count + 1];
}
else
{
num2 = fieldSerializationData.startIndex.Count;
}
Dictionary <string, int> dictionary = ObjectPool.Get <Dictionary <string, int> >();
dictionary.Clear();
for (int j = num; j < num2; j++)
{
dictionary.Add(fieldSerializationData.typeName[j], fieldSerializationData.startIndex[j]);
}
task.ID = (int)LoadField(fieldSerializationData, dictionary, typeof(int), "ID", null, null, null);
task.FriendlyName = (string)LoadField(fieldSerializationData, dictionary, typeof(string), "FriendlyName", null, null, null);
task.IsInstant = (bool)LoadField(fieldSerializationData, dictionary, typeof(bool), "IsInstant", null, null, null);
LoadNodeData(fieldSerializationData, dictionary, taskList[count]);
if (task.GetType().Equals(typeof(UnknownTask)) || task.GetType().Equals(typeof(UnknownParentTask)))
{
if (!task.FriendlyName.Contains("Unknown "))
{
task.FriendlyName = string.Format("Unknown {0}", task.FriendlyName);
}
if (!task.NodeData.Comment.Contains("Loaded from an unknown type. Was a task renamed or deleted?"))
{
task.NodeData.Comment = string.Format("Loaded from an unknown type. Was a task renamed or deleted?{0}", (!task.NodeData.Comment.Equals(string.Empty)) ? string.Format("\0{0}", task.NodeData.Comment) : string.Empty);
}
}
LoadFields(fieldSerializationData, dictionary, taskList[count], string.Empty, behaviorSource);
ObjectPool.Return(dictionary);
}
public static void LoadTask(TaskSerializationData taskSerializationData, FieldSerializationData fieldSerializationData, ref List <Task> taskList, ref BehaviorSource behaviorSource)
{
int count = taskList.Count;
int num = taskSerializationData.startIndex[count];
int num2;
if (count + 1 < taskSerializationData.startIndex.Count)
{
num2 = taskSerializationData.startIndex[count + 1];
}
else
{
num2 = fieldSerializationData.startIndex.Count;
}
Dictionary <int, int> dictionary = ObjectPool.Get <Dictionary <int, int> >();
dictionary.Clear();
for (int i = num; i < num2; i++)
{
if (!dictionary.ContainsKey(fieldSerializationData.fieldNameHash[i]))
{
dictionary.Add(fieldSerializationData.fieldNameHash[i], fieldSerializationData.startIndex[i]);
}
}
Type type = TaskUtility.GetTypeWithinAssembly(taskSerializationData.types[count]);
if (type == null)
{
bool flag = false;
for (int j = 0; j < taskSerializationData.parentIndex.Count; j++)
{
if (count == taskSerializationData.parentIndex[j])
{
flag = true;
break;
}
}
if (flag)
{
type = typeof(UnknownParentTask);
}
else
{
type = typeof(UnknownTask);
}
}
Task task = TaskUtility.CreateInstance(type) as Task;
if (task is UnknownTask)
{
UnknownTask unknownTask = task as UnknownTask;
for (int k = num; k < num2; k++)
{
unknownTask.fieldNameHash.Add(fieldSerializationData.fieldNameHash[k]);
unknownTask.startIndex.Add(fieldSerializationData.startIndex[k] - fieldSerializationData.startIndex[num]);
}
for (int l = fieldSerializationData.startIndex[num]; l <= fieldSerializationData.startIndex[num2 - 1]; l++)
{
unknownTask.dataPosition.Add(fieldSerializationData.dataPosition[l] - fieldSerializationData.dataPosition[fieldSerializationData.startIndex[num]]);
}
if (count + 1 < taskSerializationData.startIndex.Count && taskSerializationData.startIndex[count + 1] < fieldSerializationData.dataPosition.Count)
{
num2 = fieldSerializationData.dataPosition[taskSerializationData.startIndex[count + 1]];
}
else
{
num2 = fieldSerializationData.byteData.Count;
}
for (int m = fieldSerializationData.dataPosition[fieldSerializationData.startIndex[num]]; m < num2; m++)
{
unknownTask.byteData.Add(fieldSerializationData.byteData[m]);
}
unknownTask.unityObjects = fieldSerializationData.unityObjects;
}
task.Owner = (behaviorSource.Owner.GetObject() as Behavior);
taskList.Add(task);
task.ID = (int)BinaryDeserialization.LoadField(fieldSerializationData, dictionary, typeof(int), "ID", 0, null, null, null);
task.FriendlyName = (string)BinaryDeserialization.LoadField(fieldSerializationData, dictionary, typeof(string), "FriendlyName", 0, null, null, null);
task.IsInstant = (bool)BinaryDeserialization.LoadField(fieldSerializationData, dictionary, typeof(bool), "IsInstant", 0, null, null, null);
object obj;
if ((obj = BinaryDeserialization.LoadField(fieldSerializationData, dictionary, typeof(bool), "Disabled", 0, null, null, null)) != null)
{
task.Disabled = (bool)obj;
}
BinaryDeserialization.LoadNodeData(fieldSerializationData, dictionary, taskList[count]);
if (task.GetType().Equals(typeof(UnknownTask)) || task.GetType().Equals(typeof(UnknownParentTask)))
{
if (!task.FriendlyName.Contains("Unknown "))
{
task.FriendlyName = string.Format("Unknown {0}", task.FriendlyName);
}
task.NodeData.Comment = "Unknown Task. Right click and Replace to locate new task.";
}
BinaryDeserialization.LoadFields(fieldSerializationData, dictionary, taskList[count], 0, behaviorSource);
ObjectPool.Return <Dictionary <int, int> >(dictionary);
}
