Working Visual Tree With Parameters

Visual Tree tool is working with parameter lists and descriptive labels!

Author: MystikalPooka

Assets/AI.meta

@@ -0,0 +1,141 @@
+using Assets.Scripts.AI.Components;
+using Assets.Scripts.AI.Tree;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using UnityEngine;
+using Newtonsoft.Json;
+using System.ComponentModel;
+
+namespace Assets.Scripts.AI
+{
+    public class BehaviorManager : MonoBehaviour
+    {
+        public string FileName = "";
+        /// <summary>
+        /// The file to actually save/load to/from.
+        /// </summary>
+        [JsonIgnore]
+        public BehaviorTreeManagerAsset BehaviorTreeFile;
+
+        /// <summary>
+        /// Primary Runner for this manager. 
+        /// Runs all sub-behaviors/trees at the same time using the specified parallelrunner attributes.
+        /// </summary>
+        private ParallelRunner runner = new ParallelRunner("Main Root", -1, -1);
+        public ParallelRunner Runner
+        {
+            get
+            {
+                return runner;
+            }
+
+            set
+            {
+                runner = value;
+            }
+        }
+
+        /// <summary>
+        /// Seconds between every tick. At "0" this will tick every frame (basically an update loop)
+        /// </summary>
+        [SerializeField]
+        [Description("Seconds between every tick. At 0 this will tick every frame")]
+        public float SecondsBetweenTicks = 0.1f;
+
+        /// <summary>
+        /// Number of times to tick the full trees. Set to a negative number to make an infinitely running behavior tree.
+        /// </summary>
+        [SerializeField]
+
+        public int TimesToTick = 10;
+
+
+        public bool spliceNewIntoTree = false;
+        /// <summary>
+        /// A list of trees to splice into the current tree. These are not directly editable.
+        /// </summary>
+        [JsonIgnore]
+        public List<BehaviorTreeManagerAsset> SpliceList;
+
+        private bool initialized = false;
+
+        void OnEnable()
+        {
+            InitIfNeeded();
+        }
+
+        public void InitIfNeeded()
+        {
+            if (initialized == false)
+            {
+                Reinitialize();
+            }
+        }
+
+        public void Reinitialize()
+        {
+            //TODO: Change to runner extension (?)
+            Runner = BehaviorTreeFile.LoadFromJSON(this);
+
+            
+            if(spliceNewIntoTree) SpliceIntoRunner();
+            initialized = true;
+        }
+
+        //TODO: Add ILogger *(perhaps Observer pattern? This is our "singleton")*
+        //Dispatch messages to observed classes and receive that information here...
+        //How to store? List? Dictionary? My face? Cat Pictures?
+
+        /// <summary>
+        /// Ticks on the aggregate ParallelRunner then continues ticking for as long as the runner is in running state
+        /// </summary>
+        /// <returns></returns>
+        IEnumerator Start()
+        {
+            WaitForSeconds wfs = new WaitForSeconds(SecondsBetweenTicks);
+
+            Debug.Log("Starting ticks on Runner: \n\t" + Runner.ToString());
+            yield return Runner.Tick();
+            while (Runner.CurrentState == BehaviorState.Running && (TimesToTick != 0))
+            {
+                yield return StartCoroutine(Runner.Tick(wfs));
+                --TimesToTick;
+            }
+
+            Debug.Log("All Coroutines Should be DONE now! Ending all to make sure....");
+            StopAllCoroutines();
+        }
+
+        /// <summary>
+        /// Splice all trees in the "splice" area of the editor and return "true" if new trees were spliced.
+        /// </summary>
+        /// <returns></returns>
+        public bool SpliceIntoRunner()
+        {
+            if (SpliceList != null)
+            {
+                foreach (var behaviorAsset in SpliceList)
+                {
+                    if (behaviorAsset == null) return false;
+
+                    var spliceTree = behaviorAsset.LoadFromJSON();
+                    
+                    foreach (var behavior in spliceTree.Children)
+                    {
+                        if (behavior.Depth == -1 || behavior.Name == "root") continue;
+
+                        dynamic newBehavior = Activator.CreateInstance(Type.GetType(((BehaviorTreeElement)behavior).ElementType),
+                                                                        behavior.Name, behavior.Depth, behavior.ID);
+                        newBehavior.BehaviorTreeManager = this;
+                        Runner.AddChild(newBehavior);
+                    }
+                }
+
+                return true;
+            }
+            else return false;
+        }
+    }
+}

Assets/AI/BehaviorManager.cs

@@ -0,0 +1,15 @@
+namespace Assets.Scripts.AI
+{
+    //TODO: Error state? Needed? Useful?
+    /// <summary>
+    /// Null usually means this behavior has not started or is in an error state.
+    /// Fail, Success, and Running are for checking the current state from the parent object.
+    /// </summary>
+    public enum BehaviorState
+    {
+        Null = 0,
+        Fail,
+        Success,
+        Running
+    } 
+}

Assets/AI/BehaviorManager.cs.meta

@@ -0,0 +1,99 @@
+using Assets.Scripts.AI.Tree;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Assets.Scripts.AI
+{
+    [Serializable]
+    public class BehaviorTreeElement : TreeElement
+    {
+        private string _ElementType;
+        public string ElementType
+        {
+            get
+            {
+                return _ElementType;
+            }
+
+            set
+            {
+                _ElementType = value;
+            }
+        }
+
+        [Newtonsoft.Json.JsonIgnore]
+        [SerializeField]
+        private BehaviorManager _BehaviorTreeManager;
+        [Newtonsoft.Json.JsonIgnore]
+        public BehaviorManager BehaviorTreeManager
+        {
+            get
+            {
+                return _BehaviorTreeManager;
+            }
+
+            set
+            {
+                _BehaviorTreeManager = value;
+            }
+        }
+
+        public BehaviorTreeElement(string name, int depth, int id) 
+            : base(name, depth, id)
+        {
+            ElementType = this.GetType().ToString();
+            _CurrentState = BehaviorState.Null;
+            Children = new List<TreeElement>();
+        }
+
+        private BehaviorState _CurrentState;
+        [Newtonsoft.Json.JsonIgnore]
+        public BehaviorState CurrentState
+        {
+            get
+            {
+                return _CurrentState;
+            }
+            protected set
+            {
+                _CurrentState = value;
+            }
+        }
+
+        public virtual IEnumerator Tick(WaitForSeconds delayStart = null)
+        {
+            if (delayStart != null)
+            {
+                yield return delayStart;
+            }
+        }
+
+        public override string ToString()
+        {
+            var depthPad = "";
+            for (int d = 0; d < this.Depth +1; ++d)
+            {
+                depthPad += "     ";
+            }
+            var retString = depthPad + "ID: " + ID + "\n" +
+                            depthPad + "Name: " + this.Name + "\n" +
+                            depthPad +"Depth: " + Depth + "\n" +
+                            depthPad + "Type: " + ElementType.ToString() + "\n" +
+                            depthPad + "NumChildren: " + (HasChildren ? Children.Count : 0) + "\n";
+
+            if (Children != null)
+            {
+                retString += depthPad + "Children: \n";
+                foreach (var child in Children)
+                {
+                    retString += child.ToString();
+                }
+            }
+
+            return retString;
+
+        }
+    }
+}

Assets/AI/BehaviorState.cs

@@ -0,0 +1,62 @@
+using Assets.Scripts.AI.Components;
+using Assets.Scripts.AI.Tree;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEngine;
+
+namespace Assets.Scripts.AI
+{
+    [System.Serializable]
+    public class BehaviorTreeManagerAsset : ScriptableObject
+    {
+        public int TimesToTick;
+        public float SecondsBetweenTicks = 0.1f;
+
+        public string RunnerElementsJSON;
+    }
+
+    public static class AssetExtensions
+    {
+        public static ParallelRunner LoadFromJSON(this BehaviorTreeManagerAsset asset, BehaviorManager manager = null)
+        {
+            //TODO: Reload button
+            //TODO: Confirm reload from json
+            if (asset == null)
+            {
+                Debug.Log("Asset is null when loading");
+                return new ParallelRunner("Empty Root", -1, -1);
+            }
+            else
+            {
+                //Elements should be a list of dynamic objects
+                var elements =  JsonConvert.DeserializeObject<List<dynamic>>(asset.RunnerElementsJSON);
+
+                var newElements = new List<BehaviorTreeElement>();
+                foreach(dynamic el in elements)
+                {
+                    string typeName = el.ElementType;
+                    Type type = Assembly.GetAssembly(typeof(BehaviorTreeElement)).GetType(typeName);
+                    dynamic newBehavior = Activator.CreateInstance(type, (string)el.Name, (int)el.Depth, (int)el.ID);
+
+                    FieldInfo[] fields = type.GetFields();
+
+                    JsonConvert.PopulateObject(JsonConvert.SerializeObject(el), newBehavior);
+                    newElements.Add(newBehavior);
+                }
+                var str = "";
+                foreach(var e in newElements)
+                {
+                    e.BehaviorTreeManager = manager;
+                    str += e.Name + "\n";
+                }
+
+                var tree = TreeElementUtility.ListToTree(newElements);
+
+                return (ParallelRunner)tree;
+            }
+        }
+    }
+
+}