private NodeParameter GetNodeParametere(string parameterName)
        {
            NodeParameter parameter = null;

            _environmentParameterDic.TryGetValue(parameterName, out parameter);
            return(parameter);
        }
Esempio n. 2
0
        public static ParameterCompare Compare(NodeParameter self, NodeParameter parameter)
        {
            ParameterCompare result = ParameterCompare.NOT_EQUAL;

            if (self.parameterType != parameter.parameterType)
            {
                Debug.LogError("parameter Type not Equal:" + parameter.parameterName + "    " + parameter.parameterType + "    " + self.parameterType);
                return(result);
            }

            if (self.parameterType == (int)ParameterType.Float)
            {
                result = CompareFloat(self.floatValue, parameter.floatValue);
            }
            else if (self.parameterType == (int)ParameterType.Int || self.parameterType == (int)ParameterType.Long)
            {
                result = CompareLong(self.intValue, parameter.intValue);
            }
            else if (self.parameterType == (int)ParameterType.Bool)
            {
                result = CompareBool(self.boolValue, parameter.boolValue);
            }
            else if (self.parameterType == (int)ParameterType.String)
            {
                result = CompareString(self.stringValue, parameter.stringValue);
            }

            return(result);
        }
Esempio n. 3
0
        public NodeParameter Clone()
        {
            NodeParameter newParameter = new NodeParameter();

            newParameter.CloneFrom(this);
            return(newParameter);
        }
        public bool Condition(ConditionParameter conditionParameter)
        {
            bool result = true;
            List <ConditionGroupParameter> groupList = conditionParameter.GetGroupList();

            for (int i = 0; i < groupList.Count; ++i)
            {
                ConditionGroupParameter groupParameter = groupList[i];
                result = true;

                for (int j = 0; j < groupParameter.parameterList.Count; ++j)
                {
                    NodeParameter parameter = groupParameter.parameterList[j];
                    bool          value     = Condition(parameter);
                    if (!value)
                    {
                        result = false;
                        break;
                    }
                }

                if (result)
                {
                    break;
                }
            }

            return(result);
        }
        private NodeParameter CreateParameter(string parameterName, int type)
        {
            NodeParameter nodeParameter = new NodeParameter();

            nodeParameter.parameterName = parameterName;
            nodeParameter.parameterType = type;
            return(nodeParameter);
        }
        public void AddParameter(NodeParameter parameter)
        {
            NodeParameter cache = GetNodeParametere(parameter.parameterName);

            if (null == cache)
            {
                _environmentParameterDic[parameter.parameterName] = parameter;
            }
        }
 public void AddParameter(List <NodeParameter> parameterList)
 {
     //_parameterList.Clear();
     //_parameterList.AddRange(parameterList);
     for (int i = 0; i < parameterList.Count; ++i)
     {
         NodeParameter parameter = parameterList[i];
         AddParameter(parameter);
     }
 }
        public void SetParameter(string parameterName, string stringValue)
        {
            NodeParameter parameter = GetNodeParametere(parameterName);

            if (null == parameter)
            {
                parameter = CreateParameter(parameterName, (int)ParameterType.String);
                _environmentParameterDic[parameterName] = parameter;
            }
            parameter.stringValue = stringValue;
        }
        public void SetParameter(string parameterName, float floatValue)
        {
            NodeParameter parameter = GetNodeParametere(parameterName);

            if (null == parameter)
            {
                parameter = CreateParameter(parameterName, (int)ParameterType.Float);
                _environmentParameterDic[parameterName] = parameter;
            }
            parameter.floatValue = floatValue;
        }
        public bool GetParameterValue(string parameterName, ref string value)
        {
            NodeParameter parameter = GetNodeParametere(parameterName);

            if (null != parameter)
            {
                value = parameter.stringValue;
                return(true);
            }
            return(false);
        }
        public void SetParameter(string parameterName, bool boolValue)
        {
            NodeParameter parameter = GetNodeParametere(parameterName);

            if (null == parameter)
            {
                parameter = CreateParameter(parameterName, (int)ParameterType.Bool);
                _environmentParameterDic[parameterName] = parameter;
            }
            parameter.boolValue = boolValue;
        }
Esempio n. 12
0
 public void CloneFrom(NodeParameter parameter)
 {
     parameterType = parameter.parameterType;
     parameterName = parameter.parameterName;
     CNName        = parameter.CNName;
     index         = parameter.index;
     intValue      = parameter.intValue;
     longValue     = parameter.longValue;
     floatValue    = parameter.floatValue;
     boolValue     = parameter.boolValue;
     stringValue   = parameter.stringValue;
     compare       = parameter.compare;
 }
        public bool ConditionAllAnd(List <NodeParameter> parameterList)
        {
            bool result = true;

            for (int i = 0; i < parameterList.Count; ++i)
            {
                NodeParameter temp  = parameterList[i];
                bool          value = Condition(temp);
                if (!value)
                {
                    result = false;
                    break;
                }
            }

            return(result);
        }
        public bool Condition(NodeParameter parameter)
        {
            NodeParameter environmentParameter = null;

            if (!_environmentParameterDic.TryGetValue(parameter.parameterName, out environmentParameter))
            {
                return(false);
            }

            if (environmentParameter.parameterType != parameter.parameterType)
            {
                return(false);
            }

            ParameterCompare compare = ParameterCompareTool.Compare(environmentParameter, parameter);
            int value = (parameter.compare) & (int)compare;

            return(value > 0);
        }
Esempio n. 15
0
 public void AddParameter(NodeParameter parameter)
 {
     parameterList.Add(parameter);
 }