/// <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);
}
private static LayerMask BytesToLayerMask(byte[] bytes, int dataPosition)
{
LayerMask result = default(LayerMask);
result.value = BinaryDeserialization.BytesToInt(bytes, dataPosition);
return(result);
}
private static SharedVariable BytesToSharedVariable(FieldSerializationData fieldSerializationData, Dictionary <int, int> fieldIndexMap, byte[] bytes, int dataPosition, IVariableSource variableSource, bool fromField, int hashPrefix)
{
SharedVariable sharedVariable = null;
string text = (string)BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(string), "Type", hashPrefix, null, null, null);
if (string.IsNullOrEmpty(text))
{
return(null);
}
string name = (string)BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(string), "Name", hashPrefix, null, null, null);
bool flag = Convert.ToBoolean(BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), "IsShared", hashPrefix, null, null, null));
bool flag2 = Convert.ToBoolean(BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), "IsGlobal", hashPrefix, null, null, null));
if (flag && fromField)
{
if (!flag2)
{
sharedVariable = variableSource.GetVariable(name);
}
else
{
if (BinaryDeserialization.globalVariables == null)
{
BinaryDeserialization.globalVariables = GlobalVariables.Instance;
}
if (BinaryDeserialization.globalVariables != null)
{
sharedVariable = BinaryDeserialization.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(BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), "NetworkSync", hashPrefix, null, null, null));
if (!flag2)
{
sharedVariable.PropertyMapping = (string)BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(string), "PropertyMapping", hashPrefix, null, null, null);
sharedVariable.PropertyMappingOwner = (GameObject)BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(GameObject), "PropertyMappingOwner", hashPrefix, null, null, null);
sharedVariable.InitializePropertyMapping(variableSource as BehaviorSource);
}
if (!flag3)
{
sharedVariable.IsShared = true;
}
BinaryDeserialization.LoadFields(fieldSerializationData, fieldIndexMap, sharedVariable, hashPrefix, variableSource);
}
return(sharedVariable);
}
private static void LoadNodeData(FieldSerializationData fieldSerializationData, Dictionary <int, int> fieldIndexMap, Task task)
{
NodeData nodeData = new NodeData();
nodeData.Offset = (Vector2)BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(Vector2), "NodeDataOffset", 0, null, null, null);
nodeData.Comment = (string)BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(string), "NodeDataComment", 0, null, null, null);
nodeData.IsBreakpoint = (bool)BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), "NodeDataIsBreakpoint", 0, null, null, null);
nodeData.Collapsed = (bool)BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), "NodeDataCollapsed", 0, null, null, null);
object obj = BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(int), "NodeDataColorIndex", 0, null, null, null);
if (obj != null)
{
nodeData.ColorIndex = (int)obj;
}
obj = BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, typeof(List <string>), "NodeDataWatchedFields", 0, 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;
}
private static LayerMask BytesToLayerMask(byte[] bytes, int dataPosition)
{
return(new LayerMask
{
value = BinaryDeserialization.BytesToInt(bytes, dataPosition)
});
}
// Token: 0x060000E6 RID: 230 RVA: 0x00008320 File Offset: 0x00006520
public static void Load(GlobalVariables globalVariables, string version)
{
if (globalVariables == null)
{
return;
}
if (string.IsNullOrEmpty(version))
{
BinaryDeserializationDeprecated.Load(globalVariables);
return;
}
globalVariables.Variables = null;
FieldSerializationData fieldSerializationData;
if (globalVariables.VariableData == null || (fieldSerializationData = globalVariables.VariableData.fieldSerializationData).byteData == null || fieldSerializationData.byteData.Count == 0)
{
return;
}
if (fieldSerializationData.typeName.Count > 0)
{
BinaryDeserializationDeprecated.Load(globalVariables);
return;
}
VariableSerializationData variableData = globalVariables.VariableData;
fieldSerializationData.byteDataArray = fieldSerializationData.byteData.ToArray();
BinaryDeserialization.updatedSerialization = (globalVariables.Version.CompareTo("1.5.7") >= 0);
if (variableData.variableStartIndex != null)
{
List <SharedVariable> list = new List <SharedVariable>();
Dictionary <int, int> dictionary = ObjectPool.Get <Dictionary <int, int> >();
for (int i = 0; i < variableData.variableStartIndex.Count; i++)
{
int num = variableData.variableStartIndex[i];
int num2;
if (i + 1 < variableData.variableStartIndex.Count)
{
num2 = variableData.variableStartIndex[i + 1];
}
else
{
num2 = fieldSerializationData.startIndex.Count;
}
dictionary.Clear();
for (int j = num; j < num2; j++)
{
dictionary.Add(fieldSerializationData.fieldNameHash[j], fieldSerializationData.startIndex[j]);
}
SharedVariable sharedVariable = BinaryDeserialization.BytesToSharedVariable(fieldSerializationData, dictionary, fieldSerializationData.byteDataArray, variableData.variableStartIndex[i], globalVariables, false, 0);
if (sharedVariable != null)
{
list.Add(sharedVariable);
}
}
ObjectPool.Return <Dictionary <int, int> >(dictionary);
globalVariables.Variables = list;
}
}
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))
{
DeserializeJSON.Load(this.VariableData.JSONSerialization, this);
}
else
{
BinaryDeserialization.Load(this);
}
}
}
private static void LoadFields(FieldSerializationData fieldSerializationData, Dictionary <int, int> fieldIndexMap, object obj, int hashPrefix, 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 = BinaryDeserialization.LoadField(fieldSerializationData, fieldIndexMap, allFields[i].FieldType, allFields[i].Name, hashPrefix, variableSource, obj, allFields[i]);
if (obj2 != null && !object.ReferenceEquals(obj2, null) && !obj2.Equals(null))
{
allFields[i].SetValue(obj, obj2);
}
}
}
}
public static void Load(GlobalVariables globalVariables)
{
if (globalVariables == null)
{
return;
}
globalVariables.Variables = null;
FieldSerializationData fieldSerializationData;
if (globalVariables.VariableData == null || (fieldSerializationData = globalVariables.VariableData.fieldSerializationData).byteData == null || fieldSerializationData.byteData.Count == 0)
{
return;
}
VariableSerializationData variableData = globalVariables.VariableData;
fieldSerializationData.byteDataArray = fieldSerializationData.byteData.ToArray();
if (variableData.variableStartIndex != null)
{
List <SharedVariable> list = new List <SharedVariable>();
Dictionary <string, int> dictionary = ObjectPool.Get <Dictionary <string, int> >();
for (int i = 0; i < variableData.variableStartIndex.Count; i++)
{
int num = variableData.variableStartIndex[i];
int num2;
if (i + 1 < variableData.variableStartIndex.Count)
{
num2 = variableData.variableStartIndex[i + 1];
}
else
{
num2 = fieldSerializationData.startIndex.Count;
}
dictionary.Clear();
for (int j = num; j < num2; j++)
{
dictionary.Add(fieldSerializationData.typeName[j], fieldSerializationData.startIndex[j]);
}
SharedVariable sharedVariable = BinaryDeserialization.BytesToSharedVariable(fieldSerializationData, dictionary, fieldSerializationData.byteDataArray, variableData.variableStartIndex[i], globalVariables, false, string.Empty);
if (sharedVariable != null)
{
list.Add(sharedVariable);
}
}
ObjectPool.Return <Dictionary <string, int> >(dictionary);
globalVariables.Variables = list;
}
}
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);
}
public static void Load(TaskSerializationData taskData, BehaviorSource behaviorSource)
{
if (taskData != null && string.IsNullOrEmpty(taskData.Version))
{
BinaryDeserializationDeprecated.Load(taskData, behaviorSource);
return;
}
behaviorSource.EntryTask = null;
behaviorSource.RootTask = null;
behaviorSource.DetachedTasks = null;
behaviorSource.Variables = null;
FieldSerializationData fieldSerializationData;
if (taskData == null || (fieldSerializationData = taskData.fieldSerializationData).byteData == null || fieldSerializationData.byteData.Count == 0)
{
return;
}
fieldSerializationData.byteDataArray = fieldSerializationData.byteData.ToArray();
BinaryDeserialization.taskIDs = null;
BinaryDeserialization.updatedSerialization = (taskData.Version.CompareTo("1.5.7") >= 0);
if (BinaryDeserialization.updatedSerialization)
{
BinaryDeserialization.shaHashSerialization = (taskData.Version.CompareTo("1.5.9") >= 0);
}
if (taskData.variableStartIndex != null)
{
List <SharedVariable> list = new List <SharedVariable>();
Dictionary <int, int> dictionary = ObjectPool.Get <Dictionary <int, int> >();
for (int i = 0; i < taskData.variableStartIndex.Count; i++)
{
int num = taskData.variableStartIndex[i];
int num2;
if (i + 1 < taskData.variableStartIndex.Count)
{
num2 = taskData.variableStartIndex[i + 1];
}
else if (taskData.startIndex != null && taskData.startIndex.Count > 0)
{
num2 = taskData.startIndex[0];
}
else
{
num2 = fieldSerializationData.startIndex.Count;
}
dictionary.Clear();
for (int j = num; j < num2; j++)
{
dictionary.Add(fieldSerializationData.fieldNameHash[j], fieldSerializationData.startIndex[j]);
}
SharedVariable sharedVariable = BinaryDeserialization.BytesToSharedVariable(fieldSerializationData, dictionary, fieldSerializationData.byteDataArray, taskData.variableStartIndex[i], behaviorSource, false, 0);
if (sharedVariable != null)
{
list.Add(sharedVariable);
}
}
ObjectPool.Return <Dictionary <int, int> >(dictionary);
behaviorSource.Variables = list;
}
List <Task> list2 = new List <Task>();
if (taskData.types != null)
{
for (int k = 0; k < taskData.types.Count; k++)
{
BinaryDeserialization.LoadTask(taskData, fieldSerializationData, ref list2, ref behaviorSource);
}
}
if (taskData.parentIndex.Count != list2.Count)
{
Debug.LogError("Deserialization Error: parent index count does not match task list count");
return;
}
for (int l = 0; l < taskData.parentIndex.Count; l++)
{
if (taskData.parentIndex[l] == -1)
{
if (behaviorSource.EntryTask == null)
{
behaviorSource.EntryTask = list2[l];
}
else
{
if (behaviorSource.DetachedTasks == null)
{
behaviorSource.DetachedTasks = new List <Task>();
}
behaviorSource.DetachedTasks.Add(list2[l]);
}
}
else if (taskData.parentIndex[l] == 0)
{
behaviorSource.RootTask = list2[l];
}
else if (taskData.parentIndex[l] != -1)
{
ParentTask parentTask = list2[taskData.parentIndex[l]] as ParentTask;
if (parentTask != null)
{
int index = (parentTask.Children != null) ? parentTask.Children.Count : 0;
parentTask.AddChild(list2[l], index);
}
}
}
if (BinaryDeserialization.taskIDs != null)
{
foreach (BinaryDeserialization.ObjectFieldMap current in BinaryDeserialization.taskIDs.Keys)
{
List <int> list3 = BinaryDeserialization.taskIDs[current];
Type fieldType = current.fieldInfo.FieldType;
if (typeof(IList).IsAssignableFrom(fieldType))
{
if (fieldType.IsArray)
{
Type elementType = fieldType.GetElementType();
Array array = Array.CreateInstance(elementType, list3.Count);
for (int m = 0; m < array.Length; m++)
{
array.SetValue(list2[list3[m]], m);
}
current.fieldInfo.SetValue(current.obj, array);
}
else
{
Type type = fieldType.GetGenericArguments()[0];
IList list4 = TaskUtility.CreateInstance(typeof(List <>).MakeGenericType(new Type[]
{
type
})) as IList;
for (int n = 0; n < list3.Count; n++)
{
list4.Add(list2[list3[n]]);
}
current.fieldInfo.SetValue(current.obj, list4);
}
}
else
{
current.fieldInfo.SetValue(current.obj, list2[list3[0]]);
}
}
}
}
public static void Load(BehaviorSource behaviorSource)
{
BinaryDeserialization.Load(behaviorSource.TaskData, behaviorSource);
}
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);
}
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)BinaryDeserialization.LoadField(fieldSerializationData, dictionary, typeof(int), "ID", null, null, null);
task.FriendlyName = (string)BinaryDeserialization.LoadField(fieldSerializationData, dictionary, typeof(string), "FriendlyName", null, null, null);
task.IsInstant = (bool)BinaryDeserialization.LoadField(fieldSerializationData, dictionary, typeof(bool), "IsInstant", null, null, null);
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);
}
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);
}
}
BinaryDeserialization.LoadFields(fieldSerializationData, dictionary, taskList[count], string.Empty, behaviorSource);
ObjectPool.Return <Dictionary <string, int> >(dictionary);
}
