/// <summary>
        /// 重置执行
        /// </summary>
        /// <param name="unit"></param>
        protected void UndoExecuteChildGroups(ExecuteUnit unit)
        {
            var childUnits = unit.childUnits.ToArray();

            Array.Reverse(childUnits);
            foreach (var list in childUnits)
            {
                foreach (var item in list)
                {
                    if (statusDic.ContainsKey(item))
                    {
                        if (statusDic[item].statu != ExecuteStatu.UnStarted)
                        {
                            stateMechine.UnDo(item);
                        }
                        stateMechine.UnDo(item);
                        statusDic[item].Clear();
                    }
                    else
                    {
                        if (log)
                        {
                            Debug.Log("ignore:" + item.node);
                        }
                    }
                }
            }
        }
예제 #2
0
        protected override void ExecuteOnUnStarted(ExecuteUnit unit)
        {
            base.ExecuteOnUnStarted(unit);
            var logicNode = unit.node as Graph.LogicNode;

            switch (logicNode.logicType)
            {
            case Graph.LogicType.And:
                if (AllParentCompleted(unit))
                {
                    statusDic[unit].statu = ExecuteStatu.Executing;
                    StartExecuteChildGroups(unit);
                }
                break;

            case Graph.LogicType.Or:
                statusDic[unit].statu = ExecuteStatu.Executing;
                StartExecuteChildGroups(unit);
                break;

            case Graph.LogicType.ExclusiveOr:
                break;

            default:
                break;
            }
        }
 protected virtual void ExecuteOnCompleted(ExecuteUnit unit)
 {
     if (log)
     {
         Debug.Log("ExecuteCompleted:" + unit.node.name);
     }
 }
 public virtual void UnDo(ExecuteUnit unit)
 {
     if (!statusDic.ContainsKey(unit))
     {
         statusDic[unit] = new UnitStatus();
     }
 }
예제 #5
0
 public void AddParentUnit(ExecuteUnit parentUnit)
 {
     if (!parentUnits.Contains(parentUnit))
     {
         parentUnits.Add(parentUnit);
     }
 }
 protected virtual void ExecuteOnExecuting(ExecuteUnit unit)
 {
     if (log)
     {
         Debug.Log("ExecuteExecuting:" + unit.node.name);
     }
 }
예제 #7
0
        /// <summary>
        /// 首次执行
        /// </summary>
        /// <param name="unit"></param>
        protected override void ExecuteOnUnStarted(ExecuteUnit unit)
        {
            base.ExecuteOnUnStarted(unit);
            statusDic[unit].statu = ExecuteStatu.Executing;
            var operateNode = unit.node as OperaterNode;

            //判断是不是叶节点
            var leaf = unit.childUnits.Count == 0;

            if (!leaf)
            {
                for (int i = 0; i < unit.childUnits.Count; i++)
                {
                    statusDic[unit].waitUnits.Enqueue(unit.childUnits[i]);
                }
            }

            operateNode.onEndExecute = () =>
            {
                stateMechine.OnStopAction(unit.node as Graph.OperaterNode);

                if (leaf || statusDic[unit].waitUnits.Count == 0)
                {
                    statusDic[unit].statu = ExecuteStatu.Completed;
                }

                stateMechine.Execute(unit);
            };

            operateNode.OnStartExecute(stateMechine.IsAuto);
            stateMechine.OnStartAction(unit.node as Graph.OperaterNode);
        }
예제 #8
0
        public virtual void OnUnDoExecute(bool all)
        {
            StopUpdateAction(true);

            if (all)
            {
                UnDo(root);
            }
            else
            {
                if (activedUnits.Count > 0)
                {
                    var unit = activedUnits.Pop();
                    if (unit == currentUnit)
                    {
                        redoUnits.Push(unit);
                        UnDo(unit);
                        unit = activedUnits.Pop();
                    }

                    currentUnit = unit;
                    redoUnits.Push(currentUnit);
                    Debug.Log("UnDo:" + currentUnit.node);
                    UnDo(currentUnit);
                    Execute(currentUnit);
                }
            }
        }
예제 #9
0
 public virtual void OnEndExecute(bool all)
 {
     StopUpdateAction(false);
     if (all)
     {
         Complete(root);
     }
     else
     {
         if (redoUnits.Count > 0)
         {
             currentUnit = redoUnits.Pop();
             Complete(currentUnit);
             Execute(currentUnit);
         }
         else
         {
             if (startedActions.Count > 0)
             {
                 startedActions[0].OnEndExecute(true);
                 OnStopAction(startedActions[0]);
             }
         }
     }
 }
예제 #10
0
        public virtual void Execute(ExecuteUnit unit)
        {
            if (!statusDic.ContainsKey(unit))
            {
                statusDic[unit] = new UnitStatus();
            }

            switch (statusDic[unit].statu)
            {
            case ExecuteStatu.UnStarted:
                ExecuteOnUnStarted(unit);
                break;

            case ExecuteStatu.Executing:
                ExecuteOnExecuting(unit);
                break;

            case ExecuteStatu.Completed:
                ExecuteOnCompleted(unit);
                break;

            default:
                break;
            }
        }
예제 #11
0
 protected virtual void ExecuteOnUnStarted(ExecuteUnit unit)
 {
     stateMechine.activedUnits.Push(unit);
     if (log)
     {
         Debug.Log("ExecuteUnStarted:" + unit.node.name);
     }
 }
예제 #12
0
 public void Complete(ExecuteUnit unit)
 {
     if (unit != null)
     {
         SwitchState(unit);
         currentState.Complete(unit);
     }
 }
예제 #13
0
 public void UnDo(ExecuteUnit unit)
 {
     if (unit != null)
     {
         SwitchState(unit);
         currentState.UnDo(unit);
     }
 }
예제 #14
0
 public override void UnDo(ExecuteUnit unit)
 {
     base.UnDo(unit);
     if (statusDic[unit].statu != ExecuteStatu.UnStarted)
     {
         UndoExecuteChildGroups(unit);
         statusDic[unit].statu = ExecuteStatu.UnStarted;
     }
 }
예제 #15
0
 /// <summary>
 /// 结束
 /// </summary>
 /// <param name="unit"></param>
 public override void Complete(ExecuteUnit unit)
 {
     base.Complete(unit);
     if (statusDic[unit].statu != ExecuteStatu.Completed)
     {
         CompleteExecuteChildGroups(unit);
         statusDic[unit].statu = ExecuteStatu.Completed;
     }
 }
예제 #16
0
 /// <summary>
 /// 结束执行
 /// </summary>
 /// <param name="unit"></param>
 protected override void ExecuteOnCompleted(ExecuteUnit unit)
 {
     base.ExecuteOnCompleted(unit);
     if (unit.parentUnits.Count == 0)
     {
         Debug.LogError(unit.node + "have no parent!");
     }
     stateMechine.Execute(unit.parentUnits[0]);
 }
예제 #17
0
        public override void Complete(ExecuteUnit unit)
        {
            base.Complete(unit);
            CompleteExecuteChildGroups(unit);
            statusDic[unit].statu = ExecuteStatu.Completed;
            var operateNode = unit.node as OperaterNode;

            operateNode.onEndExecute = null;
            operateNode.OnEndExecute(true);
            stateMechine.OnStopAction(unit.node as Graph.OperaterNode);
        }
예제 #18
0
        private static ExecuteUnit CreateOringalUnit(Graph.ActionNode node, List <ExecuteUnit> copyEnviroment)
        {
            var unit = copyEnviroment.Find(x => x.node == node);

            if (unit == null)
            {
                unit = new ExecuteUnit(node);
                copyEnviroment.Add(unit);
            }
            return(unit);
        }
예제 #19
0
 public override void UnDo(ExecuteUnit unit)
 {
     base.UnDo(unit);
     UndoExecuteChildGroups(unit);
     if (statusDic[unit].statu != ExecuteStatu.UnStarted)
     {
         statusDic[unit].statu = ExecuteStatu.UnStarted;
         var operateNode = unit.node as OperaterNode;
         operateNode.OnUnDoExecute();
         stateMechine.OnStopAction(unit.node as Graph.OperaterNode);
     }
 }
예제 #20
0
 /// <summary>
 /// 判读执行单元当前开启的列表是否执行完成
 /// </summary>
 /// <param name="unit"></param>
 /// <returns></returns>
 protected bool HaveUnitNotComplete(ExecuteUnit unit)
 {
     if (statusDic[unit].workUnits.Count > 0)
     {
         var lastworking = statusDic[unit].workUnits.Peek();
         if (!IsGroupCompleted(lastworking))
         {
             return(true);
         }
     }
     return(false);
 }
예제 #21
0
        //再次执行
        protected override void ExecuteOnExecuting(ExecuteUnit unit)
        {
            if (HaveUnitNotComplete(unit))
            {
                return;
            }

            if (!LunchStackGroup(unit))
            {
                statusDic[unit].statu = ExecuteStatu.Completed;
                stateMechine.Complete();
            }
        }
예제 #22
0
 protected bool LunchStackGroup(ExecuteUnit unit)
 {
     if (statusDic[unit].waitUnits.Count > 0)
     {
         var units = statusDic[unit].waitUnits.Dequeue();
         statusDic[unit].workUnits.Push(units);
         stateMechine.ExecuteGroup(units);
         return(true);
     }
     else
     {
         return(false);
     }
 }
예제 #23
0
        private bool AllParentCompleted(ExecuteUnit unit)
        {
            var parentList = unit.parentUnits;

            Debug.Log(parentList.Count);
            foreach (var item in parentList)
            {
                if (item.node is Graph.OperaterNode)
                {
                    var node = item.node as Graph.OperaterNode;
                    Debug.Log(node + ": statu:" + node.Statu);
                    if (node.Statu != ExecuteStatu.Completed)
                    {
                        return(false);
                    }
                }
            }
            return(true);
        }
예제 #24
0
 public void SwitchState(ExecuteUnit unit)
 {
     if (unit.node is Graph.StartNode)
     {
         SetState(State.Start);
     }
     else if (unit.node is Graph.EndNode)
     {
         SetState(State.End);
     }
     else if (unit.node is Graph.LogicNode)
     {
         SetState(State.Logic);
     }
     else if (unit.node is Graph.OperaterNode)
     {
         SetState(State.Operate);
     }
 }
예제 #25
0
        //private static ExecuteUnit CreateCopyExecuteUnit(ExecuteUnit unit, int count)
        //{
        //    var copyUnit = new ExecuteUnit(ScriptableObject.Instantiate(unit.node));
        //    for (int i = 0; i < unit.parentUnits.Count; i++)
        //    {
        //        var parent = unit.parentUnits[i];
        //        var orignalList = parent.GetPositon(unit);
        //        orignalList.Add(copyUnit);
        //        copyUnit.AddParentUnit(unit.parentUnits[i]);
        //    }
        //    return copyUnit;
        //}

        private static ExecuteUnit CreateOriginalUnit(ActionCommand graphObj)
        {
            if (graphObj == null || graphObj.Nodes == null)
            {
                return(null);
            }
            NodeData startNodeData = graphObj.Nodes.Where(node => node.Object is Graph.StartNode).FirstOrDefault();

            if (startNodeData == null)
            {
                return(null);
            }
            Debug.Assert(startNodeData != null, "this is no start node!");
            orignalUnits.Clear();
            copyDic.Clear();
            var executeUnit = new ExecuteUnit(startNodeData.Object as Graph.StartNode);

            RetiveChildNode(graphObj, startNodeData, executeUnit);
            return(executeUnit);
        }
예제 #26
0
        /// <summary>
        /// 结束一组执行
        /// </summary>
        /// <param name="unit"></param>
        protected void CompleteExecuteChildGroups(ExecuteUnit unit)
        {
            var childs = unit.childUnits.ToArray();

            foreach (var list in childs)
            {
                foreach (var item in list)
                {
                    if (!statusDic.ContainsKey(item))
                    {
                        statusDic[item] = new UnitStatus();
                    }

                    if (statusDic[item].statu != ExecuteStatu.Completed)
                    {
                        stateMechine.Complete(item);
                    }
                }
            }
        }
예제 #27
0
        /// <summary>
        /// 开启执行
        /// </summary>
        /// <param name="unit"></param>
        protected void StartExecuteChildGroups(ExecuteUnit unit)
        {
            for (int i = 1; i < unit.childUnits.Count; i++)
            {
                statusDic[unit].waitUnits.Enqueue(unit.childUnits[i]);
            }

            if (unit.childUnits.Count > 0)
            {
                var firstGroup = unit.childUnits[0];
                stateMechine.ExecuteGroup(firstGroup);
                statusDic[unit].workUnits.Push(firstGroup);
            }
            else
            {
                //结束执行
                Debug.LogError("结束执行");
                statusDic[unit].statu = ExecuteStatu.Completed;
                stateMechine.Execute(unit);
            }
        }
예제 #28
0
 /// <summary>
 /// 将copyDic中的unit进行反向复制
 /// </summary>
 /// <param name="unit"></param>
 /// <returns></returns>
 private static ExecuteUnit DeepCopy(ExecuteUnit unit)
 {
     copyDic.Reverse();
     foreach (var item in copyDic)
     {
         var count        = item.Value;
         var copyOriginal = item.Key;
         enviroment[copyOriginal] = new List <ExecuteUnit>();
         for (int z = 0; z < count; z++)
         {
             var newUnit = MakeCopy(copyOriginal, enviroment[copyOriginal]);
             for (int i = 0; i < copyOriginal.parentUnits.Count; i++)
             {
                 var position = copyOriginal.parentUnits[i].GetPositon(copyOriginal);
                 position.Add(newUnit);
                 newUnit.parentUnits.Add(copyOriginal.parentUnits[i]);
             }
         }
     }
     return(unit);
 }
예제 #29
0
        public static ExecuteUnit MakeCopy(ExecuteUnit original, List <ExecuteUnit> enviroment)
        {
            var node = ScriptableObject.Instantiate(original.node) as Graph.ActionNode;

            (node as Graph.ActionNode).SetContext(original.node.Command);//设置上下文
            var unit = CreateOringalUnit(node, enviroment);

            if (log)
            {
                Debug.Log("MakeCopy:" + unit);
            }

            for (int i = 0; i < original.childUnits.Count; i++)
            {
                var childList = new List <ExecuteUnit>();
                for (int j = 0; j < original.childUnits[i].Count; j++)
                {
                    var childUnit = MakeCopy(original.childUnits[i][j], enviroment);
                    childList.Add(childUnit);
                }
                unit.AppendChildNodes(childList);
            }
            return(unit);
        }
예제 #30
0
        private static void RetiveChildNode(ActionCommand graphObj, NodeData parentNode, ExecuteUnit unit)
        {
            //按连接点分组
            var connectionGroup = graphObj.Connections.Where(connection => connection.FromNodeId == parentNode.Id).GroupBy(
                x =>
            {
                var port = parentNode.OutputPoints.Find(y => y.Id == x.FromNodeConnectionPointId);
                var id   = parentNode.OutputPoints.IndexOf(port);
                return(id);
            }
                ).OrderBy(x => x.Key).ToArray();

            foreach (var connections in connectionGroup)
            {
                if (log)
                {
                    Debug.Log("connection:" + connections.Key);
                }
                var childNodes = new List <ExecuteUnit>();
                foreach (var connection in connections)
                {
                    var node = graphObj.Nodes.Find(x => x.Id == connection.ToNodeId);
                    (node.Object as Graph.ActionNode).SetContext(graphObj);//设置上下文
                    var childUnit = CreateOringalUnit(node.Object as Graph.ActionNode, orignalUnits);
                    RetiveChildNode(graphObj, node, childUnit);
                    childNodes.Add(childUnit);

                    var copyCount = (connection.Object as Graph.ActionConnection).count - 1;
                    if (copyCount > 0)
                    {
                        copyDic.Add(new KeyValuePair <ExecuteUnit, int>(childUnit, copyCount));
                    }
                }
                unit.AppendChildNodes(childNodes);
            }
        }