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 TaskNode DeserializeNode(JToken token, TaskSerializationData data, BehaviourGraphView view)
{
var obj = token as JObject;
var type = TaskUtility.GetTypeWithinAssembly(obj.Value <string>("Type"));
var nData = obj.Value <JObject>("NodeData");
var position = nData.GetValue("Offset").ToObject <Vector2>(NodeSerializer.Serializer);
var node = view.CreateNode(type, position);
var name = obj.Value <string>("Name");
var id = obj.Value <int>("ID");
var instant = obj.Value <bool>("Instant");
node.title = name;
node.Data = DeserializeObject(obj, type, view, data.fieldSerializationData.unityObjects, node) as Task;
node.Data.FriendlyName = name;
node.Data.IsInstant = instant;
node.Data.ID = id;
var children = obj.GetValue("Children");
if (children is JArray array)
{
foreach (var entry in array)
{
var child = DeserializeNode(entry, data, view);
view.Connect(child, node);
}
}
return(node);
}
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());
}
}
public static void Deserialize(TaskSerializationData data, BehaviourGraphView view)
{
if (string.IsNullOrEmpty(data.JSONSerialization))
{
return;
}
var obj = JObject.Parse(data.JSONSerialization);
var entry = DeserializeNode(obj.GetValue("EntryTask"), data, view);
var root = DeserializeNode(obj.GetValue("RootTask"), data, view);
DeserializeVariables(obj.GetValue("Variables"), view);
view.Connect(root, entry);
}
public static TaskSerializationData Serialize(BehaviourGraph graph)
{
var data = new TaskSerializationData();
var entry = graph.NodesData.FirstOrDefault(x => x.Type == typeof(EntryTask));
if (entry == null)
{
Debug.LogWarning($"Graph {AssetDatabase.GetAssetPath(graph)} has no Entry node and will be left empty");
return(data);
}
var nodes = graph.GetLinked(entry);
var root = nodes.FirstOrDefault();
var objects = new List <UnityEngine.Object>();
var node = new JObject
{
{ "EntryTask", SerializeNode(graph, entry, objects, false) },
{ "RootTask", SerializeNode(graph, root, objects) },
{ "Variables", SerializeVariables(graph) }
};
var sb = new StringBuilder();
Serializer.Serialize(new StringWriter(sb), node);
data.JSONSerialization = sb.ToString();
data.Version = "1.5.7";
data.fieldSerializationData = new FieldSerializationData {
unityObjects = objects
};
return(data);
}
public static void Load(TaskSerializationData taskData, BehaviorSource behaviorSource)
{
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();
taskIDs = null;
if (taskData.variableStartIndex != null)
{
List <SharedVariable> list = new List <SharedVariable>();
Dictionary <string, int> dictionary = ObjectPool.Get <Dictionary <string, 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.typeName[j], fieldSerializationData.startIndex[j]);
}
SharedVariable sharedVariable = BytesToSharedVariable(fieldSerializationData, dictionary, fieldSerializationData.byteDataArray, taskData.variableStartIndex[i], behaviorSource, false, string.Empty);
if (sharedVariable != null)
{
list.Add(sharedVariable);
}
}
ObjectPool.Return(dictionary);
behaviorSource.Variables = list;
}
List <Task> list2 = new List <Task>();
if (taskData.types != null)
{
for (int k = 0; k < taskData.types.Count; k++)
{
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 (taskIDs != null)
{
foreach (ObjectFieldMap current in 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]]);
}
}
}
}
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);
}
