Exemple #1
0
		public override BTResult Tick () {
			for (int i=0; i<children.Count; i++) {
				if(_completeChildNumList.Contains(i))
					continue;
				BTNode child = children[i];
				
				switch (child.Tick()) {
				case BTResult.Running:
					isRunning = true;
					continue;
				case BTResult.Success:
					child.Clear();
					_completeChildNumList.Add(i);
					return BTResult.Success;
				case BTResult.Failed:	
					child.Clear();
					_completeChildNumList.Add(i);
					continue;
				}
			}
			
			if (_completeChildNumList.Count == children.Count) {
				isRunning = false;
				_completeChildNumList.Clear ();
				return BTResult.Failed;
			}
			return BTResult.Running;
		}
Exemple #2
0
        private BTResult TickFromActiveChild()
        {
            if (_activeChildIndex == -1)
            {
                _activeChildIndex = 0;
            }

            for (; _activeChildIndex < children.Count; _activeChildIndex++)
            {
                BTNode activeChild = children[_activeChildIndex];

                switch (activeChild.Tick())
                {
                case BTResult.Running:
                    isRunning = true;
                    return(BTResult.Running);

                case BTResult.Success:
                    activeChild.Clear();
                    continue;

                case BTResult.Failed:
                    activeChild.Clear();
                    _activeChildIndex = -1;
                    isRunning         = false;
                    return(BTResult.Failed);
                }
            }

            _activeChildIndex = -1;
            isRunning         = false;
            return(BTResult.Success);
        }
        public override void Clear()
        {
            base.Clear();

            switch (clearOpt)
            {
            case BTClearOpt.Default:
                if (_activeChildIndex != -1)
                {
                    children[_activeChildIndex].Clear();
                }
                break;

            case BTClearOpt.Selected:
                foreach (BTNode child in selectedChildrenForClear)
                {
                    int index = children.IndexOf(child);
                    if (index > _previousSuccessChildIndex)
                    {
                        child.Clear();
                    }
                }
                break;

            case BTClearOpt.DefaultAndSelected:
                if (_activeChildIndex != -1)
                {
                    BTNode activeChild = children[_activeChildIndex];
                    if (!selectedChildrenForClear.Contains(activeChild))
                    {
                        activeChild.Clear();
                    }
                }
                int split = Mathf.Max(_activeChildIndex, _previousSuccessChildIndex);
                foreach (BTNode child in selectedChildrenForClear)
                {
                    int index = children.IndexOf(child);
                    if (index > split)
                    {
                        child.Clear();
                    }
                }
                break;

            case BTClearOpt.All:
                split = Mathf.Max(_activeChildIndex - 1, _previousSuccessChildIndex);
                foreach (BTNode child in children)
                {
                    int index = children.IndexOf(child);
                    if (index > split)
                    {
                        child.Clear();
                    }
                }
                break;
            }

            _activeChildIndex          = -1;
            _previousSuccessChildIndex = -1;
        }
Exemple #4
0
 public void Clear()
 {
     if (null != mRoot)
     {
         mRoot.Clear();
     }
 }
        public override BTResult Tick()
        {
            int startPos = Random.Range(0, children.Count);

            for (int a = 0; a < children.Count; a++)
            {
                int i = a + startPos;
                if (i > children.Count)
                {
                    i -= children.Count;
                }
                BTNode child = children[i];

                switch (child.Tick())
                {
                case BTResult.Running:
                    if (_activeChildIndex != i && _activeChildIndex != -1)
                    {
                        children[_activeChildIndex].Clear();
                    }
                    _activeChildIndex          = i;
                    _previousSuccessChildIndex = -1;
                    isRunning = true;
                    return(BTResult.Running);

                case BTResult.Success:
                    if (_activeChildIndex != i && _activeChildIndex != -1)
                    {
                        children[_activeChildIndex].Clear();
                    }
                    child.Clear();
                    _activeChildIndex          = -1;
                    _previousSuccessChildIndex = i;
                    isRunning = false;
                    return(BTResult.Success);

                case BTResult.Failed:
                    child.Clear();
                    continue;
                }
            }

            _activeChildIndex          = -1;
            _previousSuccessChildIndex = -1;
            isRunning = false;
            return(BTResult.Failed);
        }
 // selects the active child
 protected override bool DoEvaluate()
 {
     foreach (BTNode child in children)
     {
         if (child.Evaluate())
         {
             if (_activeChild != null && _activeChild != child)
             {
                 _activeChild.Clear();
             }
             _activeChild = child;
             return(true);
         }
     }
     _activeChild = null;
     return(false);
 }
 protected override bool DoEvaluate()
 {
     if (_activeChild != null)
     {
         bool result = _activeChild.Evaluate();
         if (!result)
         {
             _activeChild.Clear();
             _activeChild = null;
             _activeIndex = -1;
         }
         return(result);
     }
     else
     {
         return(children[0].Evaluate());
     }
 }
Exemple #8
0
        public override BTStatus Step()
        {
            for (int i = 0; i < m_Children.Count; i++)
            {
                BTNode   pNode   = m_Children[i];
                BTStatus pStatus = pNode.Step();
                switch (pStatus)
                {
                case BTStatus.Running:
                {
                    if (m_ActiveIndex != i && m_ActiveIndex != -1)
                    {
                        m_Children[m_ActiveIndex].Clear();
                    }
                    m_ActiveIndex = i;
                    m_PreviaIndex = -1;
                    m_IsRunning   = true;
                    return(BTStatus.Running);
                }

                case BTStatus.Success:
                {
                    if (m_ActiveIndex != i && m_ActiveIndex != -1)
                    {
                        m_Children[m_ActiveIndex].Clear();
                    }
                    pNode.Clear();
                    m_ActiveIndex = -1;
                    m_PreviaIndex = i;
                    m_IsRunning   = false;
                    return(BTStatus.Success);
                }

                case BTStatus.Failure:
                {
                    pNode.Clear();
                    return(BTStatus.Failure);
                }
                }
            }

            m_IsRunning = false;
            return(BTStatus.Failure);
        }
Exemple #9
0
        public override BTStatus Step()
        {
            if (m_ActiveIndex == -1)
            {
                m_ActiveIndex = UnityEngine.Random.Range(0, m_Children.Count);
            }

            if (m_Children.Count > 0)
            {
                BTNode   pNode   = m_Children[m_ActiveIndex];
                BTStatus pStatus = pNode.Step();
                switch (pStatus)
                {
                case BTStatus.Running:
                {
                    m_IsRunning = true;
                    return(BTStatus.Running);
                }

                case BTStatus.Success:
                {
                    pNode.Clear();
                    m_ActiveIndex = -1;
                    m_PreviaIndex = m_ActiveIndex;
                    m_IsRunning   = false;
                    return(BTStatus.Success);
                }

                case BTStatus.Failure:
                {
                    pNode.Clear();
                    m_ActiveIndex = -1;
                    m_PreviaIndex = -1;
                    m_IsRunning   = false;
                    return(BTStatus.Failure);
                }
                }
            }
            m_ActiveIndex = -1;
            m_PreviaIndex = -1;
            m_IsRunning   = false;
            return(BTStatus.Failure);
        }
Exemple #10
0
        public override BTResult Tick()
        {
            for (int i = 0; i < children.Count; i++)
            {
                BTNode child = children[i];

                switch (child.Tick())
                {
                case BTResult.Running:
                    if (_activeChildIndex != i && _activeChildIndex != -1)
                    {
                        children[_activeChildIndex].Clear();
                    }
                    _activeChildIndex          = i;
                    _previousSuccessChildIndex = -1;
                    isRunning = true;
                    return(BTResult.Running);

                case BTResult.Success:
                    if (_activeChildIndex != i && _activeChildIndex != -1)
                    {
                        children[_activeChildIndex].Clear();
                    }
                    child.Clear();
                    _activeChildIndex          = -1;
                    _previousSuccessChildIndex = i;
                    isRunning = false;
                    return(BTResult.Success);

                case BTResult.Failed:
                    child.Clear();
                    continue;
                }
            }

            _activeChildIndex          = -1;
            _previousSuccessChildIndex = -1;
            isRunning = false;
            return(BTResult.Failed);
        }
Exemple #11
0
        private void RunBackground()
        {
            for (int i = _runningChildren.Count - 1; i >= 0; i--)
            {
                BTNode   child  = _runningChildren[i];
                BTResult result = child.Tick();

                if (result != BTResult.Running)
                {
                    child.Clear();
                    _runningChildren.RemoveAt(i);
                }
            }
        }
Exemple #12
0
        public override void Clear()
        {
            base.Clear();

            for (int i = 0, max = ChildNodes.Count; i < max; ++i)
            {
                BTNode tmpNode = ChildNodes[i];

                if (null != tmpNode)
                {
                    tmpNode.Clear();
                }
            }
        }
Exemple #13
0
        public override BTResult Tick()
        {
            if (_primaryChild == null)
            {
                Debug.LogError("Primary Child not set!");
            }

            BTResult primaryChildResult = _primaryChild.Tick();

            if (primaryChildResult == BTResult.Running)
            {
                RunBackground();
                isRunning = true;
                return(BTResult.Running);
            }
            else
            {
                _shouldClearPrimaryChild = false;
                _primaryChild.Clear();
                isRunning = false;
                return(primaryChildResult);
            }
        }
Exemple #14
0
        public override EBTStatus Step()
        {
            if (mActiveIndex == -1)
            {
                mActiveIndex = 0;
            }
            for (; mActiveIndex < mChildren.Count; mActiveIndex++)
            {
                BTNode    pNode   = mChildren[mActiveIndex];
                EBTStatus pStatus = pNode.Step();
                switch (pStatus)
                {
                case EBTStatus.BT_RUNNING:
                {
                    mIsRunning = true;
                    return(EBTStatus.BT_RUNNING);
                }

                case EBTStatus.BT_SUCCESS:
                {
                    pNode.Clear();
                    continue;
                }

                case EBTStatus.BT_FAILURE:
                {
                    mActiveIndex = -1;
                    mIsRunning   = false;
                    pNode.Clear();
                    return(EBTStatus.BT_FAILURE);
                }
                }
            }
            mActiveIndex = -1;
            mIsRunning   = false;
            return(EBTStatus.BT_SUCCESS);
        }
Exemple #15
0
        public override BTStatus Step()
        {
            if (m_ActiveIndex == -1)
            {
                m_ActiveIndex = 0;
            }
            for (; m_ActiveIndex < m_Children.Count; m_ActiveIndex++)
            {
                BTNode   pNode   = m_Children[m_ActiveIndex];
                BTStatus pStatus = pNode.Step();
                switch (pStatus)
                {
                case BTStatus.Running:
                {
                    m_IsRunning = true;
                    return(BTStatus.Running);
                }

                case BTStatus.Success:
                {
                    pNode.Clear();
                    continue;
                }

                case BTStatus.Failure:
                {
                    m_ActiveIndex = -1;
                    m_IsRunning   = false;
                    pNode.Clear();
                    return(BTStatus.Failure);
                }
                }
            }
            m_ActiveIndex = -1;
            m_IsRunning   = false;
            return(BTStatus.Success);
        }
Exemple #16
0
        public override EBTStatus Step()
        {
            for (int i = 0; i < mChildren.Count; i++)
            {
                if (mFinishChildrenIndexList.Contains(i))
                {
                    continue;
                }
                BTNode    pNode   = mChildren[i];
                EBTStatus pStatus = pNode.Step();

                if (pStatus != EBTStatus.BT_RUNNING)
                {
                    pNode.Clear();
                    mFinishChildrenIndexList.Add(i);
                }
            }

            mIsRunning = (mFinishChildrenIndexList.Count < mChildren.Count);
            return((mIsRunning) ? EBTStatus.BT_RUNNING : EBTStatus.BT_SUCCESS);
        }
Exemple #17
0
        public override BTStatus Step()
        {
            for (int i = 0; i < m_Children.Count; i++)
            {
                if (m_FinishChildrenIndexList.Contains(i))
                {
                    continue;
                }
                BTNode   pNode   = m_Children[i];
                BTStatus pStatus = pNode.Step();

                if (pStatus != BTStatus.Running)
                {
                    pNode.Clear();
                    m_FinishChildrenIndexList.Add(i);
                }
            }

            m_IsRunning = (m_FinishChildrenIndexList.Count < m_Children.Count);
            return((m_IsRunning) ? BTStatus.Running : BTStatus.Success);
        }
Exemple #18
0
        public override void Clear()
        {
            base.Clear();

            switch (clearOpt)
            {
            case BTClearOpt.Default:
                if (_activeChildIndex != -1)
                {
                    children[_activeChildIndex].Clear();
                }
                break;

            case BTClearOpt.Selected:
                foreach (BTNode child in selectedChildrenForClear)
                {
                    int index = children.IndexOf(child);
                    // greater than active child index means they are not cleared yet
                    // also if _activeChildIndex is -1, then all selected children will be cleared
                    if (index >= _activeChildIndex)
                    {
                        child.Clear();
                    }
                }
                break;

            case BTClearOpt.DefaultAndSelected:
                if (_activeChildIndex != -1)
                {
                    BTNode activeChild = children[_activeChildIndex];
                    if (!selectedChildrenForClear.Contains(activeChild))
                    {
                        activeChild.Clear();
                    }
                }
                foreach (BTNode child in selectedChildrenForClear)
                {
                    int index = children.IndexOf(child);
                    if (index >= _activeChildIndex)
                    {
                        child.Clear();
                    }
                }
                break;

            case BTClearOpt.All:
                if (_activeChildIndex > -1)
                {
                    for (int i = _activeChildIndex; i < children.Count; i++)
                    {
                        if (i < 0)
                        {
                            continue;
                        }
                        children[i].Clear();
                    }
                }
                break;
            }

            _activeChildIndex = -1;
        }