/**
     * Begins a node and attaches the coroutine to this object
     * If you use this method you MUST call the node.OnComplete method
     * after it yields
     */
    public Coroutine BeginNode(BehaviorNode node)
    {
        node.mReturnValue = BehaviorReturn.Running;

        //process
        return StartCoroutine(node.Process(this));
    }

 public ExporterCpp(BehaviorNode node, string outputFolder, string filename, List<string> includedFilenames = null)
     : base(node, outputFolder, filename, includedFilenames)
 {
     //automatically create an extra level of path
     _outputFolder = Path.Combine(Path.GetFullPath(_outputFolder), "behaviac_generated");
     _filename = "behaviors/generated_behaviors.h";
 }

        public override NodeViewData CreateNodeViewData(NodeViewData parent, BehaviorNode rootBehavior)
        {
            NodeViewData nvd = base.CreateNodeViewData(parent, rootBehavior);
            nvd.ChangeShape(this.IsEndState ? NodeShape.RoundedRectangle : NodeShape.Rectangle);

            return nvd;
        }

		public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result)
		{
			if(_genericChildren.ChildCount <1)
				result.Add( new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.DecoratorHasNoChildError) );

			base.CheckForErrors(rootBehavior, result);
		}

        public override NodeViewData CreateNodeViewData(NodeViewData parent, BehaviorNode rootBehavior)
        {
            NodeViewData nvd = base.CreateNodeViewData(parent, rootBehavior);
            nvd.ChangeShape(NodeShape.Ellipse);

            return nvd;
        }

		public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result)
		{
			if(_genericChildren.ChildCount <2)
				result.Add( new Node.ErrorCheck(this, ErrorCheckLevel.Warning, Resources.SelectorOnlyOneChildError) );
			else if(_genericChildren.ChildCount <1)
				result.Add( new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.SelectorNoChildrenError) );

			base.CheckForErrors(rootBehavior, result);
		}

        public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result)
        {
            if (this._signal.ChildCount == 0)
            {
                result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.ImpulseWithoutEventError));
            }

            base.CheckForErrors(rootBehavior, result);
        }

        public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result)
        {
            if (this.Children.Count < 2)
            {
                result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "There should be at least 2 condition children."));
            }

            base.CheckForErrors(rootBehavior, result);
        }

        public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result)
        {
            if (this._method == null)
            {
                result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Warning, Resources.RandomGeneratorNotSpecified));
            }

            base.CheckForErrors(rootBehavior, result);
        }

 internal static void SetProperty(BehaviorNode behavior, string agentTypename, string agentName, string valueName, string valueStr)
 {
     foreach(ParametersDock dock in _parameterDocks)
     {
         if (dock.AgentName == agentName)
         {
             dock.setProperty(behavior, valueName, valueStr);
             break;
         }
     }
 }

        public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result) {
            if (_do_sequence_error_check) {
                if (_genericChildren.EnableChildCount < 1)
                { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.SequenceNoChildrenError)); }

                else if (_genericChildren.EnableChildCount < 2)
                { result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Warning, Resources.SequenceOnlyOneChildError)); }
            }

            base.CheckForErrors(rootBehavior, result);
        }

        public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result)
        {
            Type valueType = this._time.GetValueType();

            if (valueType != typeof(float))
            {
                result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Time must be a float type!"));
            }

            base.CheckForErrors(rootBehavior, result);
        }

    /**
     * Ctor
     * @param stack The BehaviorVariable id of stack to push to
     * @param item The BehaviorVariable id item variable
     */
    public PushToStack(BehaviorNode parent, string stack, string item)
        : base(parent)
    {
        mStack = stack;
        mItem = item;

        //make sure input is instantiated
        if(input == null)
        {
            input = new object[1];
        }
    }

 public NodeViewDataStyled(NodeViewData parent, BehaviorNode rootBehavior, Node node, Pen borderPen, Brush backgroundBrush, Brush draggedBackgroundBrush, string label, string description, int minWidth = 120, int minHeight = 35) :
     base(parent, rootBehavior, node,
          NodeShape.RoundedRectangle,
          new Style(backgroundBrush, null, Brushes.White),
          new Style(null, DefaultCurrentBorderPen, null),
          new Style(null, __defaultSelectedBorderPen, null),
          new Style(draggedBackgroundBrush, null, null),
          new Style(null, __highlightedBorderPen, null),
          new Style(null, __updatedBorderPen, null),
          new Style(null, __prefabBorderPen, null),
          label, __defaultLabelFont, __profileLabelFont, __profileLabelBoldFont, minWidth, minHeight, description) {
 }

    public BehaviorReturn mReturnValue = BehaviorReturn.Invalid; /**< as process is ran in coroutines returning a BehaviorReturn type is not allowed. So we store it here and check it with ReturnValue property */

    #endregion Fields

    #region Constructors

    public BehaviorNode(BehaviorNode parent)
    {
        Composite compNode = parent as Composite;
        if (compNode != null)
            compNode.AddChild(this);
        else
        {
            Decorator decNode = parent as Decorator;
            if (decNode != null)
                decNode.AddChild(this);
        }
    }

        public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result)
        {
            foreach (BaseNode child in _genericChildren.Children)
            {
                if (!(child is WithPrecondition))
                {
                    result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.SelectorLoopChildChildError));
                }
            }

            base.CheckForErrors(rootBehavior, result);
        }

        public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result)
        {
            if (_Task.Child == null)
            {
                result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.NoMethosError));
            }

            if (!(this.Parent is Task))
            {
                result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, Resources.MethodParentError));
            }

            base.CheckForErrors(rootBehavior, result);
        }

        public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result)
        {
            base.CheckForErrors(rootBehavior, result);

            if (this._bDoneWithinFrame)
            {
                long count = this.GetCount();

                if (count == -1)
                {
                    result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "when 'DoneWithinFrame' is selected, Count should not be -1 as an endless loop!"));
                }
            }
        }

    /**
     * Coroutine to begin the BehaviorTree
     * @param node The root node
     * @return IEnumerator (see Unity Coroutine)
     */
    private IEnumerator Coroutine_Execute(BehaviorNode node)
    {
        //set this to true as the behavior tree is running
        mStatus = BehaviorReturn.Running;

        mCurrent = node;

        yield return BeginNode(mCurrent);

        //the status of this tree will be whatever the value of the first node was
        mStatus = mCurrent.mReturnValue;

        Debug.Log("BEHAVIOR COMPLETE " + mStatus);
        mCurrent = null;
    }

        public override void CheckForErrors(BehaviorNode rootBehavior, List<ErrorCheck> result)
        {
            Type valueType = (this._time != null) ? this._time.ValueType : null;

            if (valueType == null)
            {
                result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Time is not set!"));
            }
            else if (!Plugin.IsIntergerType(valueType) && !Plugin.IsFloatType(valueType))
            {
                result.Add(new Node.ErrorCheck(this, ErrorCheckLevel.Error, "Time must be a float type!"));
            }

            base.CheckForErrors(rootBehavior, result);
        }