Ejemplo n.º 1
0
        private void ExcuteEffectNode(SEBaseEffectNode parent)
        {
            var type = parent.NodeType;

            switch (type)
            {
            case EEffectNodeType.YesNoCondition:
            {
                var yesNoNode  = parent as SEYesNoNode;
                var methodNode = m_ConditionMethods [yesNoNode.EffectParam.Method](yesNoNode.EffectParam.Params);
                if (methodNode)
                {
                    var yesMethods = yesNoNode.YesMethods;
                    for (int i = 0; i < yesMethods.Count; i++)
                    {
                        ExcuteEffectNode(yesMethods [i]);
                    }
                }
                else
                {
                    var noMethods = yesNoNode.NoMethods;
                    for (int i = 0; i < noMethods.Count; i++)
                    {
                        ExcuteEffectNode(noMethods [i]);
                    }
                }
            }
            break;

            case EEffectNodeType.ExcuteEffectNode:
            {
                var excuteNode    = parent as SEExcuteEffectNode;
                var playerMethods = excuteNode.ExcuteMethods;
                for (int i = 0; i < playerMethods.Count; i++)
                {
                    m_ExcuteMethods [playerMethods[i].Method](playerMethods[i].Params);
                }
            }
            break;
            }
        }
        private SEBaseEffectNode ReadNode(Dictionary <string, object> nodeData, bool firstNode = false)
        {
            m_NodeCount++;
            EEffectNodeType type = EEffectNodeType.None;

            if (nodeData.ContainsKey("Method"))
            {
                type = EEffectNodeType.YesNoCondition;
            }
            else
            {
                type = EEffectNodeType.ExcuteEffectNode;
            }
            var id = type.ToString() + m_NodeCount;

            switch (type)
            {
            case EEffectNodeType.YesNoCondition:
            {
                SEYesNoNode yesNo = null;
                if (firstNode)
                {
                    m_CurrentNode = new SEYesNoNode();
                    yesNo         = m_CurrentNode as SEYesNoNode;
                }
                else
                {
                    yesNo = new SEYesNoNode();
                }
                yesNo.ID       = id;
                yesNo.NodeType = type;
                var methodName = string.Empty;
                var pars       = ParseStringToObjects(nodeData["Method"].ToString(), out methodName);
                yesNo.EffectParam.Method = methodName;
                yesNo.EffectParam.Params = pars;
                var yesMethods = nodeData["YesMethods"] as List <object>;
                var noMethods  = nodeData["NoMethods"] as List <object>;
                for (int i = 0; i < yesMethods.Count; i++)
                {
                    var yesData = yesMethods[i] as Dictionary <string, object>;
                    yesNo.YesMethods.Add(ReadNode(yesData));
                }
                for (int i = 0; i < noMethods.Count; i++)
                {
                    var noData = noMethods[i] as Dictionary <string, object>;
                    yesNo.NoMethods.Add(ReadNode(noData));
                }
                return(yesNo);
            }

            default:
            case EEffectNodeType.ExcuteEffectNode:
            {
                SEExcuteEffectNode excuteMethod = null;
                if (firstNode)
                {
                    m_CurrentNode = new SEExcuteEffectNode();
                    excuteMethod  = m_CurrentNode as SEExcuteEffectNode;
                }
                else
                {
                    excuteMethod = new SEExcuteEffectNode();
                }
                excuteMethod.ID       = id;
                excuteMethod.NodeType = type;
                var pars = nodeData["ExcuteMethods"] as List <object>;
                for (int i = 0; i < pars.Count; i++)
                {
                    var methodName = string.Empty;
                    var par        = ParseStringToObjects(pars[i].ToString(), out methodName);
                    excuteMethod.ExcuteMethods.Add(new SEEffectParam()
                        {
                            Method = methodName, Params = par
                        });
                }
                return(excuteMethod);
            }
            }
            return(null);
        }