public void AddElements(IList <T> elements, TreeElement parent, int insertPosition)
{
if (elements == null)
{
throw new ArgumentNullException("elements", "elements is null");
}
if (elements.Count == 0)
{
throw new ArgumentNullException("elements", "elements Count is 0: nothing to add");
}
if (parent == null)
{
throw new ArgumentNullException("parent", "parent is null");
}
if (parent.children == null)
{
parent.children = new List <TreeElement>();
}
parent.children.InsertRange(insertPosition, elements.Cast <TreeElement> ());
foreach (var element in elements)
{
element.parent = parent;
element.depth = parent.depth + 1;
TreeElementUtility.UpdateDepthValues(element);
}
TreeElementUtility.TreeToList(m_Root, m_Data);
Changed();
}
public void Reinitialize()
{
//TODO: Change to runner extension
Runner = BehaviorTreeFile.LoadFromJSON(this);
if (spliceNewIntoTree)
{
SpliceIntoRunner();
}
TreeElementUtility.TreeToList(Runner, treeList);
var treeQuery = treeList.AsEnumerable();
TreeSubject = new Subject <BehaviorTreeElement>();
TreeSubject.Subscribe(xr =>
{
var logEntry = new BehaviorLogEntry(
loggerName: BehaviorLogger.Name,
logType: LogType.Log,
timestamp: DateTime.Now,
message: "Ticked!",
behaviorID: xr.ID,
newState: xr.CurrentState,
ticknum: xr.NumberOfTicksReceived.Value,
context: this,
state: xr);
BehaviorLogger.Raw(logEntry);
Debug.Log("xr debug initialize");
}).AddTo(this);
initialized = true;
}
public static void TestTreeToListWorks()
{
// Arrange
TestElement root = new TestElement("root", -1);
root.children = new List <TreeElement>();
root.children.Add(new TestElement("A", 0));
root.children.Add(new TestElement("B", 0));
root.children.Add(new TestElement("C", 0));
root.children[1].children = new List <TreeElement>();
root.children[1].children.Add(new TestElement("Bchild", 1));
root.children[1].children[0].children = new List <TreeElement>();
root.children[1].children[0].children.Add(new TestElement("Bchildchild", 2));
// Test
List <TestElement> result = new List <TestElement>();
TreeElementUtility.TreeToList(root, result);
// Assert
string[] namesInCorrectOrder = { "root", "A", "B", "Bchild", "Bchildchild", "C" };
Assert.AreEqual(namesInCorrectOrder.Length, result.Count, "Result count is not match");
for (int i = 0; i < namesInCorrectOrder.Length; ++i)
{
Assert.AreEqual(namesInCorrectOrder[i], result[i].name);
}
TreeElementUtility.ValidateDepthValues(result);
}
/// <summary>
/// Saves a scriptable object behavior tree and sets the active asset back to the behavior manager
/// </summary>
/// <param name="behaviorManager"></param>
/// <param name="filePath"></param>
/// <param name="asset"></param>
public static void SaveBehaviorAsset(this BehaviorManager behaviorManager, string filePath,
BehaviorTreeManagerAsset asset, Merge root = null)
{
if (asset == null)
{
asset = ScriptableObject.CreateInstance <BehaviorTreeManagerAsset>();
}
var runnerElementList = new List <BehaviorTreeElement>();
Debug.Log("Attempting save at path: " + filePath);
int indexS = filePath.LastIndexOf("/") + 1;
int indexD = filePath.LastIndexOf(".") - indexS;
asset.name = filePath.Substring(indexS, indexD);
var json = asset.RunnerElementsJSON;
if (behaviorManager != null)
{
behaviorManager.Reinitialize();
asset.MilliSecondsBetweenTicks = behaviorManager.MilliSecondsBetweenTicks;
asset.TimesToTick = behaviorManager.TimesToTick;
TreeElementUtility.TreeToList(behaviorManager.Runner, runnerElementList);
}
if (root != null)
{
TreeElementUtility.TreeToList(root, runnerElementList);
}
if (json == "" || runnerElementList.Count == 0)
{
var runner = new Merge("Extension Root", -1, -1);
runnerElementList.Add(runner);
json = JsonConvert.SerializeObject(runnerElementList, Formatting.Indented);
}
json = JsonConvert.SerializeObject(runnerElementList, Formatting.Indented);
asset.RunnerElementsJSON = json;
Debug.Log("JSON Saved: " + asset.RunnerElementsJSON);
var curPath = AssetDatabase.GetAssetPath(asset);
if (curPath == null || curPath == "")
{
Debug.Log("Creating asset: " + filePath);
AssetDatabase.CreateAsset(asset, filePath);
}
//AssetDatabase.Refresh();
EditorUtility.SetDirty(asset);
AssetDatabase.SaveAssets();
}
public IList <MyTreeElement> GetData()
{
var treeElements = new List <MyTreeElement>();
var root = new MyTreeElement("Root", -1, ++IDCounter, "root");
treeElements.Add(root);
//var child = new MyTreeElement("Element " + IDCounter, root.depth + 1, ++IDCounter);
//treeElements.Add(child);
foreach (Node node in NodeTypes.nodes.Keys)
{
string path = NodeTypes.nodes[node].adress;
if (path.Contains("/"))
{
// is inside a group
string[] subContents = path.Split('/');
string folderPath = subContents[0];
FindAndAddToParent(root, subContents, 0, node.GetID);
}
else
{
var ele = new MyTreeElement(path, root.depth + 1, ++IDCounter, node.GetID);
treeElements.Add(ele);
}
}
var sub = new MyTreeElement("Subroutines", 0, ++IDCounter, "folder");
root.AddChild(sub);
var subs = GetAtPath <NodeCanvas>("TextureWang/Subroutines");//Resources.LoadAll<NodeCanvas>(NodeEditor.editorPath + "Resources/Saves/");
foreach (var x in subs)
{
var s = new MyTreeElement(x.name, sub.depth + 1, ++IDCounter, "");
sub.AddChild(s);
s.m_Canvas = x;
}
sub = new MyTreeElement("UserSubroutines", 0, ++IDCounter, "folder");
root.AddChild(sub);
subs = GetAtPath <NodeCanvas>("TextureWang/UserSubroutines");//Resources.LoadAll<NodeCanvas>(NodeEditor.editorPath + "Resources/Saves/");
foreach (var x in subs)
{
var s = new MyTreeElement(x.name, sub.depth + 1, ++IDCounter, "");
sub.AddChild(s);
s.m_Canvas = x;
}
var res = new List <MyTreeElement>();
TreeElementUtility.TreeToList(root, res);
return(res);
}
public void Reinitialize()
{
//TODO: Change to runner extension
Runner = BehaviorTreeFile.LoadFromJSON(this);
if (spliceNewIntoTree)
{
SpliceIntoRunner();
}
List <BehaviorTreeElement> treeList = new List <BehaviorTreeElement>();
TreeElementUtility.TreeToList(Runner, treeList);
var treeQuery = from el in treeList
select el;
TreeStream =
treeQuery
.ToObservable()
.Do(xr =>
{
xr.ObserveEveryValueChanged(x => x.NumberOfTicksReceived)
.Do(x =>
{
var logEntry = new BehaviorLogEntry(
loggerName: BehaviorLogger.Name,
logType: LogType.Log,
timestamp: DateTime.Now,
message: "Ticked!",
behaviorID: xr.ID,
newState: xr.CurrentState,
ticknum: xr.NumberOfTicksReceived.Value,
context: this,
state: xr);
BehaviorLogger.Raw(logEntry);
})
.Subscribe()
.AddTo(this);
});
TreeStream.Subscribe().AddTo(this);
initialized = true;
}
IList <BehaviorTreeElement> GetData()
{
if (_BehaviorTreeManagerAsset == null)
{
CreateNewTree();
}
var treeRoot = _BehaviorTreeManagerAsset.LoadFromJSON();
if (treeRoot == null)
{
treeRoot = new Merge("New Root", -1, -1);
}
var treeList = new List <BehaviorTreeElement>();
TreeElementUtility.TreeToList(treeRoot, treeList);
return(treeList);
}
public void MoveElements(TreeElement parentElement, int insertionIndex, List <TreeElement> elements)
{
if (insertionIndex < 0)
{
throw new ArgumentException(
"Invalid input: insertionIndex is -1, client needs to decide what index elements should be reparented at");
}
// Invalid reparenting input
if (parentElement == null)
{
return;
}
// We are moving items so we adjust the insertion index to accomodate that any items above the insertion index is removed before inserting
if (insertionIndex > 0)
{
insertionIndex -= parentElement.children.GetRange(0, insertionIndex).Count(elements.Contains);
}
// Remove draggedItems from their parents
foreach (var draggedItem in elements)
{
draggedItem.parent.children.Remove(draggedItem); // remove from old parent
draggedItem.parent = parentElement; // set new parent
}
if (parentElement.children == null)
{
parentElement.children = new List <TreeElement>();
}
// Insert dragged items under new parent
parentElement.children.InsertRange(insertionIndex, elements);
TreeElementUtility.UpdateDepthValues(root);
TreeElementUtility.TreeToList(m_Root, m_Data);
Changed();
}
public void RemoveElements(IList <T> elements)
{
foreach (var element in elements)
{
if (element == m_Root)
{
throw new ArgumentException("It is not allowed to remove the root element");
}
}
var commonAncestors = TreeElementUtility.FindCommonAncestorsWithinList(elements);
foreach (var element in commonAncestors)
{
element.parent.children.Remove(element);
element.parent = null;
}
TreeElementUtility.TreeToList(m_Root, m_Data);
Changed();
}
public void AddElement(T element, TreeElement parent, int insertPosition)
{
if (element == null)
{
throw new ArgumentNullException("element", "element is null");
}
if (parent == null)
{
throw new ArgumentNullException("parent", "parent is null");
}
if (parent.children == null)
{
parent.children = new List <TreeElement> ();
}
parent.children.Insert(insertPosition, element);
element.parent = parent;
TreeElementUtility.UpdateDepthValues(parent);
TreeElementUtility.TreeToList(m_Root, m_Data);
Changed();
}
