/// <summary>
/// 通过序列化信息解析数据
/// </summary>
/// <param name="force">强制解析</param>
/// <param name="behaviorSource"></param>
/// <returns></returns>
public bool CheckForSerialization(bool force, BehaviorSource behaviorSource = null)
{
bool flag = (behaviorSource == null) ? this.HasSerialized : behaviorSource.HasSerialized;
if (!flag || force)
{
if (behaviorSource != null)
{
behaviorSource.HasSerialized = true;
}
else
{
this.HasSerialized = true;
}
if (this.mTaskData != null && !string.IsNullOrEmpty(this.mTaskData.JSONSerialization))
{
JSONDeserialization.Load(this.mTaskData, (behaviorSource != null) ? behaviorSource : this);
}
else
{
BinaryDeserialization.Load(this.mTaskData, (behaviorSource != null) ? behaviorSource : this);
}
return(true);
}
return(false);
}
// Token: 0x06000157 RID: 343 RVA: 0x0000BFA4 File Offset: 0x0000A1A4
public static void Load(string serialization, GlobalVariables globalVariables, string version)
{
if (globalVariables == null)
{
return;
}
if (string.IsNullOrEmpty(version))
{
JSONDeserializationDeprecated.Load(serialization, globalVariables);
return;
}
Dictionary <string, object> dictionary = MiniJSON.Deserialize(serialization) as Dictionary <string, object>;
if (dictionary == null)
{
Debug.Log("Failed to deserialize");
return;
}
if (globalVariables.VariableData == null)
{
globalVariables.VariableData = new VariableSerializationData();
}
JSONDeserialization.updatedSerialization = (globalVariables.Version.CompareTo("1.5.7") >= 0);
JSONDeserialization.DeserializeVariables(globalVariables, dictionary, globalVariables.VariableData.fieldSerializationData.unityObjects);
}
public void CheckForSerialization(bool force)
{
if (force || this.mVariables == null || (this.mVariables.Count > 0 && this.mVariables[0] == null))
{
if (this.VariableData != null && !string.IsNullOrEmpty(this.VariableData.JSONSerialization))
{
JSONDeserialization.Load(this.VariableData.JSONSerialization, this, this.mVersion);
}
else
{
BinaryDeserialization.Load(this, this.mVersion);
}
}
}
// Token: 0x06000158 RID: 344 RVA: 0x0000C038 File Offset: 0x0000A238
private static void DeserializeVariables(IVariableSource variableSource, Dictionary <string, object> dict, List <UnityEngine.Object> unityObjects)
{
object obj;
if (dict.TryGetValue("Variables", out obj))
{
List <SharedVariable> list = new List <SharedVariable>();
IList list2 = obj as IList;
for (int i = 0; i < list2.Count; i++)
{
SharedVariable item = JSONDeserialization.DeserializeSharedVariable(list2[i] as Dictionary <string, object>, variableSource, true, unityObjects);
list.Add(item);
}
variableSource.SetAllVariables(list);
}
}
// Token: 0x0600015A RID: 346 RVA: 0x0000C33C File Offset: 0x0000A53C
private static NodeData DeserializeNodeData(Dictionary <string, object> dict, Task task)
{
NodeData nodeData = new NodeData();
object obj;
if (dict.TryGetValue("Offset", out obj))
{
nodeData.Offset = JSONDeserialization.StringToVector2((string)obj);
}
if (dict.TryGetValue("FriendlyName", out obj))
{
task.FriendlyName = (string)obj;
}
if (dict.TryGetValue("Comment", out obj))
{
nodeData.Comment = (string)obj;
}
if (dict.TryGetValue("IsBreakpoint", out obj))
{
nodeData.IsBreakpoint = Convert.ToBoolean(obj);
}
if (dict.TryGetValue("Collapsed", out obj))
{
nodeData.Collapsed = Convert.ToBoolean(obj);
}
if (dict.TryGetValue("ColorIndex", out obj))
{
nodeData.ColorIndex = Convert.ToInt32(obj);
}
if (dict.TryGetValue("WatchedFields", out obj))
{
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);
}
}
}
return(nodeData);
}
// Token: 0x0600015D RID: 349 RVA: 0x0000CB28 File Offset: 0x0000AD28
private static object ValueToObject(Task task, Type type, object obj, IVariableSource variableSource, List <UnityEngine.Object> unityObjects)
{
if (typeof(SharedVariable).IsAssignableFrom(type))
{
SharedVariable sharedVariable = JSONDeserialization.DeserializeSharedVariable(obj as Dictionary <string, object>, variableSource, false, unityObjects);
if (sharedVariable == null)
{
sharedVariable = (TaskUtility.CreateInstance(type) as SharedVariable);
}
return(sharedVariable);
}
if (type.Equals(typeof(UnityEngine.Object)) || type.IsSubclassOf(typeof(UnityEngine.Object)))
{
return(JSONDeserialization.IndexToUnityObject(Convert.ToInt32(obj), unityObjects));
}
if (!type.IsPrimitive)
{
if (!type.Equals(typeof(string)))
{
goto IL_B0;
}
}
try
{
return(Convert.ChangeType(obj, type));
}
catch (Exception)
{
return(null);
}
IL_B0:
if (type.IsSubclassOf(typeof(Enum)))
{
try
{
return(Enum.Parse(type, (string)obj));
}
catch (Exception)
{
return(null);
}
}
if (type.Equals(typeof(Vector2)))
{
return(JSONDeserialization.StringToVector2((string)obj));
}
if (type.Equals(typeof(Vector3)))
{
return(JSONDeserialization.StringToVector3((string)obj));
}
if (type.Equals(typeof(Vector4)))
{
return(JSONDeserialization.StringToVector4((string)obj));
}
if (type.Equals(typeof(Quaternion)))
{
return(JSONDeserialization.StringToQuaternion((string)obj));
}
if (type.Equals(typeof(Matrix4x4)))
{
return(JSONDeserialization.StringToMatrix4x4((string)obj));
}
if (type.Equals(typeof(Color)))
{
return(JSONDeserialization.StringToColor((string)obj));
}
if (type.Equals(typeof(Rect)))
{
return(JSONDeserialization.StringToRect((string)obj));
}
if (type.Equals(typeof(LayerMask)))
{
return(JSONDeserialization.ValueToLayerMask(Convert.ToInt32(obj)));
}
if (type.Equals(typeof(AnimationCurve)))
{
return(JSONDeserialization.ValueToAnimationCurve((Dictionary <string, object>)obj));
}
object obj2 = TaskUtility.CreateInstance(type);
JSONDeserialization.DeserializeObject(task, obj2, obj as Dictionary <string, object>, variableSource, unityObjects);
return(obj2);
}
// Token: 0x0600015C RID: 348 RVA: 0x0000C670 File Offset: 0x0000A870
private static void DeserializeObject(Task task, object obj, Dictionary <string, object> dict, IVariableSource variableSource, List <UnityEngine.Object> unityObjects)
{
if (dict == null)
{
return;
}
FieldInfo[] allFields = TaskUtility.GetAllFields(obj.GetType());
for (int i = 0; i < allFields.Length; i++)
{
string key = (!JSONDeserialization.updatedSerialization) ? (allFields[i].FieldType.Name.GetHashCode() + allFields[i].Name.GetHashCode()).ToString() : (allFields[i].FieldType.Name + allFields[i].Name);
object obj2;
if (dict.TryGetValue(key, out obj2))
{
if (typeof(IList).IsAssignableFrom(allFields[i].FieldType))
{
IList list = obj2 as IList;
if (list != null)
{
Type type;
if (allFields[i].FieldType.IsArray)
{
type = allFields[i].FieldType.GetElementType();
}
else
{
Type type2 = allFields[i].FieldType;
while (!type2.IsGenericType)
{
type2 = type2.BaseType;
}
type = type2.GetGenericArguments()[0];
}
bool flag = type.Equals(typeof(Task)) || type.IsSubclassOf(typeof(Task));
if (flag)
{
if (JSONDeserialization.taskIDs != null)
{
List <int> list2 = new List <int>();
for (int j = 0; j < list.Count; j++)
{
list2.Add(Convert.ToInt32(list[j]));
}
JSONDeserialization.taskIDs.Add(new JSONDeserialization.TaskField(task, allFields[i]), list2);
}
}
else if (allFields[i].FieldType.IsArray)
{
Array array = Array.CreateInstance(type, list.Count);
for (int k = 0; k < list.Count; k++)
{
if (list[k] == null)
{
array.SetValue(null, k);
}
else
{
array.SetValue(JSONDeserialization.ValueToObject(task, type, list[k], variableSource, unityObjects), k);
}
}
allFields[i].SetValue(obj, array);
}
else
{
IList list3;
if (allFields[i].FieldType.IsGenericType)
{
list3 = (TaskUtility.CreateInstance(typeof(List <>).MakeGenericType(new Type[]
{
type
})) as IList);
}
else
{
list3 = (TaskUtility.CreateInstance(allFields[i].FieldType) as IList);
}
for (int l = 0; l < list.Count; l++)
{
if (list[l] == null)
{
list3.Add(null);
}
else
{
list3.Add(JSONDeserialization.ValueToObject(task, type, list[l], variableSource, unityObjects));
}
}
allFields[i].SetValue(obj, list3);
}
}
}
else
{
Type fieldType = allFields[i].FieldType;
if (fieldType.Equals(typeof(Task)) || fieldType.IsSubclassOf(typeof(Task)))
{
if (TaskUtility.HasAttribute(allFields[i], typeof(InspectTaskAttribute)))
{
Dictionary <string, object> dictionary = obj2 as Dictionary <string, object>;
Type typeWithinAssembly = TaskUtility.GetTypeWithinAssembly(dictionary["Type"] as string);
if (typeWithinAssembly != null)
{
Task task2 = TaskUtility.CreateInstance(typeWithinAssembly) as Task;
JSONDeserialization.DeserializeObject(task2, task2, dictionary, variableSource, unityObjects);
allFields[i].SetValue(task, task2);
}
}
else if (JSONDeserialization.taskIDs != null)
{
List <int> list4 = new List <int>();
list4.Add(Convert.ToInt32(obj2));
JSONDeserialization.taskIDs.Add(new JSONDeserialization.TaskField(task, allFields[i]), list4);
}
}
else
{
allFields[i].SetValue(obj, JSONDeserialization.ValueToObject(task, fieldType, obj2, variableSource, unityObjects));
}
}
}
else if (typeof(SharedVariable).IsAssignableFrom(allFields[i].FieldType) && !allFields[i].FieldType.IsAbstract)
{
if (dict.TryGetValue((allFields[i].FieldType.Name.GetHashCode() + allFields[i].Name.GetHashCode()).ToString(), out obj2))
{
SharedVariable sharedVariable = TaskUtility.CreateInstance(allFields[i].FieldType) as SharedVariable;
sharedVariable.SetValue(JSONDeserialization.ValueToObject(task, allFields[i].FieldType, obj2, variableSource, unityObjects));
allFields[i].SetValue(obj, sharedVariable);
}
else
{
SharedVariable sharedVariable2 = TaskUtility.CreateInstance(allFields[i].FieldType) as SharedVariable;
SharedVariable sharedVariable3 = allFields[i].GetValue(obj) as SharedVariable;
if (sharedVariable3 != null)
{
sharedVariable2.SetValue(sharedVariable3.GetValue());
}
allFields[i].SetValue(obj, sharedVariable2);
}
}
}
}
// Token: 0x0600015B RID: 347 RVA: 0x0000C490 File Offset: 0x0000A690
private static SharedVariable DeserializeSharedVariable(Dictionary <string, object> dict, IVariableSource variableSource, bool fromSource, List <UnityEngine.Object> unityObjects)
{
if (dict == null)
{
return(null);
}
SharedVariable sharedVariable = null;
object obj;
if (!fromSource && variableSource != null && dict.TryGetValue("Name", out obj))
{
object value;
dict.TryGetValue("IsGlobal", out value);
if (!dict.TryGetValue("IsGlobal", out value) || !Convert.ToBoolean(value))
{
sharedVariable = variableSource.GetVariable(obj as string);
}
else
{
if (JSONDeserialization.globalVariables == null)
{
JSONDeserialization.globalVariables = GlobalVariables.Instance;
}
if (JSONDeserialization.globalVariables != null)
{
sharedVariable = JSONDeserialization.globalVariables.GetVariable(obj as string);
}
}
}
Type typeWithinAssembly = TaskUtility.GetTypeWithinAssembly(dict["Type"] as string);
if (typeWithinAssembly == null)
{
return(null);
}
bool flag = true;
if (sharedVariable == null || !(flag = sharedVariable.GetType().Equals(typeWithinAssembly)))
{
sharedVariable = (TaskUtility.CreateInstance(typeWithinAssembly) as SharedVariable);
sharedVariable.Name = (dict["Name"] as string);
object obj2;
if (dict.TryGetValue("IsShared", out obj2))
{
sharedVariable.IsShared = Convert.ToBoolean(obj2);
}
if (dict.TryGetValue("IsGlobal", out obj2))
{
sharedVariable.IsGlobal = Convert.ToBoolean(obj2);
}
if (dict.TryGetValue("NetworkSync", out obj2))
{
sharedVariable.NetworkSync = Convert.ToBoolean(obj2);
}
if (!sharedVariable.IsGlobal && dict.TryGetValue("PropertyMapping", out obj2))
{
sharedVariable.PropertyMapping = (obj2 as string);
if (dict.TryGetValue("PropertyMappingOwner", out obj2))
{
sharedVariable.PropertyMappingOwner = (JSONDeserialization.IndexToUnityObject(Convert.ToInt32(obj2), unityObjects) as GameObject);
}
sharedVariable.InitializePropertyMapping(variableSource as BehaviorSource);
}
if (!flag)
{
sharedVariable.IsShared = true;
}
JSONDeserialization.DeserializeObject(null, sharedVariable, dict, variableSource, unityObjects);
}
return(sharedVariable);
}
// Token: 0x06000159 RID: 345 RVA: 0x0000C0A0 File Offset: 0x0000A2A0
public static Task DeserializeTask(BehaviorSource behaviorSource, Dictionary <string, object> dict, ref Dictionary <int, Task> IDtoTask, List <UnityEngine.Object> unityObjects)
{
Task task = null;
try
{
Type type = TaskUtility.GetTypeWithinAssembly(dict["Type"] as string);
if (type == null)
{
if (dict.ContainsKey("Children"))
{
type = typeof(UnknownParentTask);
}
else
{
type = typeof(UnknownTask);
}
}
task = (TaskUtility.CreateInstance(type) as Task);
if (task is UnknownTask)
{
UnknownTask unknownTask = task as UnknownTask;
unknownTask.JSONSerialization = MiniJSON.Serialize(dict);
}
}
catch (Exception)
{
}
if (task == null)
{
return(null);
}
task.Owner = (behaviorSource.Owner.GetObject() as Behavior);
task.ID = Convert.ToInt32(dict["ID"]);
object obj;
if (dict.TryGetValue("Name", out obj))
{
task.FriendlyName = (string)obj;
}
if (dict.TryGetValue("Instant", out obj))
{
task.IsInstant = Convert.ToBoolean(obj);
}
if (dict.TryGetValue("Disabled", out obj))
{
task.Disabled = Convert.ToBoolean(obj);
}
IDtoTask.Add(task.ID, task);
task.NodeData = JSONDeserialization.DeserializeNodeData(dict["NodeData"] as Dictionary <string, object>, task);
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.";
}
JSONDeserialization.DeserializeObject(task, task, dict, behaviorSource, unityObjects);
if (task is ParentTask && dict.TryGetValue("Children", out obj))
{
ParentTask parentTask = task as ParentTask;
if (parentTask != null)
{
foreach (object obj2 in (obj as IEnumerable))
{
Dictionary <string, object> dict2 = (Dictionary <string, object>)obj2;
Task child = JSONDeserialization.DeserializeTask(behaviorSource, dict2, ref IDtoTask, unityObjects);
int index = (parentTask.Children != null) ? parentTask.Children.Count : 0;
parentTask.AddChild(child, index);
}
}
}
return(task);
}
// Token: 0x06000156 RID: 342 RVA: 0x0000BBB0 File Offset: 0x00009DB0
public static void Load(TaskSerializationData taskData, BehaviorSource behaviorSource)
{
if (taskData != null && string.IsNullOrEmpty(taskData.Version))
{
JSONDeserializationDeprecated.Load(taskData, behaviorSource);
return;
}
behaviorSource.EntryTask = null;
behaviorSource.RootTask = null;
behaviorSource.DetachedTasks = null;
behaviorSource.Variables = null;
Dictionary <string, object> dictionary;
if (!JSONDeserialization.serializationCache.TryGetValue(taskData.JSONSerialization.GetHashCode(), out dictionary))
{
dictionary = (MiniJSON.Deserialize(taskData.JSONSerialization) as Dictionary <string, object>);
JSONDeserialization.serializationCache.Add(taskData.JSONSerialization.GetHashCode(), dictionary);
}
if (dictionary == null)
{
Debug.Log("Failed to deserialize");
return;
}
JSONDeserialization.taskIDs = new Dictionary <JSONDeserialization.TaskField, List <int> >();
JSONDeserialization.updatedSerialization = (taskData.Version.CompareTo("1.5.7") >= 0);
Dictionary <int, Task> dictionary2 = new Dictionary <int, Task>();
JSONDeserialization.DeserializeVariables(behaviorSource, dictionary, taskData.fieldSerializationData.unityObjects);
if (dictionary.ContainsKey("EntryTask"))
{
behaviorSource.EntryTask = JSONDeserialization.DeserializeTask(behaviorSource, dictionary["EntryTask"] as Dictionary <string, object>, ref dictionary2, taskData.fieldSerializationData.unityObjects);
}
if (dictionary.ContainsKey("RootTask"))
{
behaviorSource.RootTask = JSONDeserialization.DeserializeTask(behaviorSource, dictionary["RootTask"] as Dictionary <string, object>, ref dictionary2, taskData.fieldSerializationData.unityObjects);
}
if (dictionary.ContainsKey("DetachedTasks"))
{
List <Task> list = new List <Task>();
foreach (object obj in (dictionary["DetachedTasks"] as IEnumerable))
{
Dictionary <string, object> dict = (Dictionary <string, object>)obj;
list.Add(JSONDeserialization.DeserializeTask(behaviorSource, dict, ref dictionary2, taskData.fieldSerializationData.unityObjects));
}
behaviorSource.DetachedTasks = list;
}
if (JSONDeserialization.taskIDs != null && JSONDeserialization.taskIDs.Count > 0)
{
foreach (JSONDeserialization.TaskField key in JSONDeserialization.taskIDs.Keys)
{
List <int> list2 = JSONDeserialization.taskIDs[key];
Type fieldType = key.fieldInfo.FieldType;
if (key.fieldInfo.FieldType.IsArray)
{
int num = 0;
for (int i = 0; i < list2.Count; i++)
{
Task task = dictionary2[list2[i]];
if (task.GetType().Equals(fieldType.GetElementType()) || task.GetType().IsSubclassOf(fieldType.GetElementType()))
{
num++;
}
}
Array array = Array.CreateInstance(fieldType.GetElementType(), num);
int num2 = 0;
for (int j = 0; j < list2.Count; j++)
{
Task task2 = dictionary2[list2[j]];
if (task2.GetType().Equals(fieldType.GetElementType()) || task2.GetType().IsSubclassOf(fieldType.GetElementType()))
{
array.SetValue(task2, num2);
num2++;
}
}
key.fieldInfo.SetValue(key.task, array);
}
else
{
Task task3 = dictionary2[list2[0]];
if (task3.GetType().Equals(key.fieldInfo.FieldType) || task3.GetType().IsSubclassOf(key.fieldInfo.FieldType))
{
key.fieldInfo.SetValue(key.task, task3);
}
}
}
JSONDeserialization.taskIDs = null;
}
}
