Ejemplo n.º 1
0
        public static BehaviorCompare CompareLong(long longValue1, long longValue2)
        {
            BehaviorCompare behaviorCompare = BehaviorCompare.INVALID;

            if (longValue1 > longValue2)
            {
                behaviorCompare |= BehaviorCompare.GREATER;
                behaviorCompare |= BehaviorCompare.NOT_EQUAL;
            }
            else if (longValue1 < longValue2)
            {
                behaviorCompare |= BehaviorCompare.LESS;
                behaviorCompare |= BehaviorCompare.NOT_EQUAL;
            }
            else
            {
                behaviorCompare |= BehaviorCompare.EQUALS;
            }

            if (longValue1 >= longValue2)
            {
                behaviorCompare |= BehaviorCompare.GREATER_EQUALS;
            }

            if (longValue1 <= longValue2)
            {
                behaviorCompare |= BehaviorCompare.LESS_EQUAL;
            }

            return(behaviorCompare);
        }
Ejemplo n.º 2
0
        public BehaviorCompare Compare(BehaviorParameter parameter)
        {
            BehaviorCompare behaviorCompare = BehaviorCompare.NOT_EQUAL;

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

            if (parameterType == (int)BehaviorParameterType.Float)
            {
                behaviorCompare = CompareFloat(parameter);
            }
            else if (parameterType == (int)BehaviorParameterType.Int)
            {
                behaviorCompare = CompareInt(parameter);
            }
            else
            {
                behaviorCompare = CompareBool(parameter);
            }

            return(behaviorCompare);
        }
Ejemplo n.º 3
0
        public BehaviorCompare Compare(BehaviorParameter parameter)
        {
            BehaviorCompare behaviorCompare = BehaviorCompare.NOT_EQUAL;

            if (parameterType != parameter.parameterType)
            {
                ////ProDebug.Logger.LogError("parameter Type not Equal:" + parameter.parameterName + "    " + parameter.parameterType + "    " + parameterType);
                return(behaviorCompare);
            }

            if (parameterType == (int)BehaviorParameterType.Float)
            {
                behaviorCompare = CompareFloat(this.floatValue, parameter.floatValue);
            }
            else if (parameterType == (int)BehaviorParameterType.Int)
            {
                behaviorCompare = CompareInt(this.intValue, parameter.intValue);
            }
            else if (parameterType == (int)BehaviorParameterType.Long)
            {
                behaviorCompare = CompareLong(this.longValue, parameter.longValue);
            }
            else if (parameterType == (int)BehaviorParameterType.Bool)
            {
                behaviorCompare = CompareBool(this.boolValue, parameter.boolValue);
            }
            else if (parameterType == (int)BehaviorParameterType.String)
            {
                behaviorCompare = CompareString(this.stringValue, parameter.stringValue);
            }

            return(behaviorCompare);
        }
Ejemplo n.º 4
0
        public bool Compare(BehaviorParameter parameter)
        {
            if (parameterType != parameter.parameterType)
            {
                Debug.LogError("parameter Type not Equal:" + parameter.parameterName + "    " + parameter.parameterType + "    " + parameterType);
                return(false);
            }

            BehaviorCompare behaviorCompare = BehaviorCompare.NOT_EQUAL;

            if (parameterType == (int)BehaviorParameterType.Float)
            {
                behaviorCompare = (Compare(parameter.floatValue));
            }
            else if (parameterType == (int)BehaviorParameterType.Int)
            {
                behaviorCompare = (Compare(parameter.intValue));
            }
            else
            {
                behaviorCompare = (Compare(parameter.boolValue));
            }

            return((compare & (int)behaviorCompare) > 0);
        }
Ejemplo n.º 5
0
        private BehaviorCompare Compare(float a, float b)
        {
            BehaviorCompare behaviorCompare = BehaviorCompare.INVALID;

            if (a > b)
            {
                behaviorCompare |= BehaviorCompare.GREATER;
            }

            if (a >= b)
            {
                behaviorCompare |= BehaviorCompare.GREATER_EQUALS;
            }

            if (a == b)
            {
                behaviorCompare |= BehaviorCompare.EQUALS;
            }

            if (a <= b)
            {
                behaviorCompare |= BehaviorCompare.LESS_EQUAL;
            }

            if (a < b)
            {
                behaviorCompare |= BehaviorCompare.LESS;
            }

            return(behaviorCompare);
        }
Ejemplo n.º 6
0
        public static BehaviorCompare CompareFloat(float floatValue1, float floatValue2)
        {
            BehaviorCompare BehaviorCompare = BehaviorCompare.INVALID;

            if (floatValue1 > floatValue2)
            {
                BehaviorCompare |= BehaviorCompare.GREATER;
            }
            else if (floatValue1 < floatValue2)
            {
                BehaviorCompare |= BehaviorCompare.LESS;
            }

            return(BehaviorCompare);
        }
Ejemplo n.º 7
0
        public BehaviorCompare CompareFloat(BehaviorParameter parameter)
        {
            BehaviorCompare BehaviorCompare = BehaviorCompare.INVALID;

            if (this.floatValue > parameter.floatValue)
            {
                BehaviorCompare |= BehaviorCompare.GREATER;
            }

            if (this.floatValue < parameter.floatValue)
            {
                BehaviorCompare |= BehaviorCompare.LESS;
            }

            return(BehaviorCompare);
        }
Ejemplo n.º 8
0
    public bool CompareParameter(BehaviorParameter parameter)
    {
        BehaviorParameter environmentParameter = null;

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

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

        BehaviorCompare behaviorCompare = environmentParameter.Compare(parameter);
        int             value           = (parameter.compare) & (int)behaviorCompare;

        return(value > 0);
    }
Ejemplo n.º 9
0
        public BehaviorCompare CompareInt(BehaviorParameter parameter)
        {
            BehaviorCompare behaviorCompare = BehaviorCompare.INVALID;

            behaviorCompare = CompareFloat(parameter);

            if (this.intValue > parameter.intValue)
            {
                behaviorCompare |= BehaviorCompare.GREATER;
            }

            if (this.intValue < parameter.intValue)
            {
                behaviorCompare |= BehaviorCompare.LESS;
            }

            if (this.intValue == parameter.intValue)
            {
                behaviorCompare |= BehaviorCompare.EQUALS;
            }

            if (this.intValue != parameter.intValue)
            {
                behaviorCompare |= BehaviorCompare.NOT_EQUAL;
            }

            if (this.intValue >= parameter.intValue)
            {
                behaviorCompare |= BehaviorCompare.GREATER_EQUALS;
            }

            if (this.intValue <= parameter.intValue)
            {
                behaviorCompare |= BehaviorCompare.LESS_EQUAL;
            }

            return(behaviorCompare);
        }
Ejemplo n.º 10
0
        public BehaviorCompare CompareBool(BehaviorParameter parameter)
        {
            BehaviorCompare behaviorCompare = (this.boolValue == parameter.boolValue) ? BehaviorCompare.EQUALS : BehaviorCompare.NOT_EQUAL;

            return(behaviorCompare);
        }
Ejemplo n.º 11
0
    public bool Condition(BehaviorParameter parameter)
    {
        BehaviorCompare behaviorCompare = BehaviorCompare.EQUALS;

        if (parameter.parameterType == (int)(BehaviorParameterType.Int))
        {
            int intValue = 0;
            if (!GetParameterValue(parameter.parameterName, ref intValue))
            {
                return(false);
            }
            behaviorCompare = BehaviorParameter.CompareInt(intValue, parameter.intValue);
        }
        else if (parameter.parameterType == (int)(BehaviorParameterType.Long))
        {
            long longValue = 0;
            if (!GetParameterValue(parameter.parameterName, ref longValue))
            {
                return(false);
            }
            behaviorCompare = BehaviorParameter.CompareLong(longValue, parameter.longValue);
        }
        else if (parameter.parameterType == (int)(BehaviorParameterType.Float))
        {
            float floatValue = 0;
            if (!GetParameterValue(parameter.parameterName, ref floatValue))
            {
                return(false);
            }
            behaviorCompare = BehaviorParameter.CompareFloat(floatValue, parameter.floatValue);
        }
        else if (parameter.parameterType == (int)(BehaviorParameterType.Bool))
        {
            bool boolValue = false;
            if (!GetParameterValue(parameter.parameterName, ref boolValue))
            {
                return(false);
            }
            behaviorCompare = BehaviorParameter.CompareBool(boolValue, parameter.boolValue);
        }
        else if (parameter.parameterType == (int)(BehaviorParameterType.String))
        {
            string stringValue = string.Empty;
            if (!GetParameterValue(parameter.parameterName, ref stringValue))
            {
                return(false);
            }
            behaviorCompare = BehaviorParameter.CompareString(stringValue, parameter.stringValue);
        }

        int value = (parameter.compare) & (int)behaviorCompare;

        return(value > 0);

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

        //if (environmentParameter.parameterType != parameter.parameterType)
        //{
        //    //ProDebug.Logger.LogError("parameter Type not Equal:" + environmentParameter.parameterName + "    " + environmentParameter.parameterType + "    " + parameter.parameterType);
        //    return false;
        //}

        //BehaviorCompare behaviorCompare = environmentParameter.Compare(parameter);
        //int value = (parameter.compare) & (int)behaviorCompare;
        //return value > 0;
    }
Ejemplo n.º 12
0
        public static BehaviorParameter Draw(BehaviorParameter behaviorParameter, DrawParameterType drawParameterType, Action DelCallBack)
        {
            if (null == behaviorParameter)
            {
                return(behaviorParameter);
            }

            {
                string[] parameterNameArr = EnumNames.GetEnumNames <BehaviorParameterType>();
                int      index            = EnumNames.GetEnumIndex <BehaviorParameterType>((BehaviorParameterType)(behaviorParameter.parameterType));
                BehaviorParameterType behaviorParameterType = EnumNames.GetEnum <BehaviorParameterType>(index);

                bool enableChangeType = (drawParameterType == DrawParameterType.GLOBAL_PARAMETER_ADD);
                GUI.enabled = enableChangeType;
                {
                    index = EditorGUILayout.Popup(index, parameterNameArr);
                    behaviorParameter.parameterType = (int)EnumNames.GetEnum <BehaviorParameterType>(index);
                    GUILayout.Space(5);
                }
                GUI.enabled = true;
            }

            EditorGUILayout.BeginHorizontal();
            {
                if (drawParameterType == DrawParameterType.NODE_PARAMETER)
                {
                    List <BehaviorParameter> parameterList = BehaviorManager.Instance.GlobalParameter.parameterList;
                    string[] parameterArr = new string[parameterList.Count];
                    int      index        = -1;
                    for (int i = 0; i < parameterList.Count; ++i)
                    {
                        BehaviorParameter p = parameterList[i];
                        parameterArr[i] = p.parameterName;
                        if (behaviorParameter.parameterName.CompareTo(p.parameterName) == 0)
                        {
                            index = i;
                        }
                    }

                    int result = EditorGUILayout.Popup(index, parameterArr, GUILayout.ExpandWidth(true));
                    if (result != index)
                    {
                        behaviorParameter.parameterName = parameterArr[result];
                    }
                }
                else if (drawParameterType == DrawParameterType.GLOBAL_PARAMETER ||
                         (drawParameterType == DrawParameterType.GLOBAL_PARAMETER_ADD) ||
                         drawParameterType == DrawParameterType.RUNTIME_PARAMETER)
                {
                    GUI.enabled = (drawParameterType == DrawParameterType.GLOBAL_PARAMETER_ADD);
                    behaviorParameter.parameterName = EditorGUILayout.TextField(behaviorParameter.parameterName);
                    GUI.enabled = true;
                }

                BehaviorCompare[] compareEnumArr = new BehaviorCompare[] { };
                if (behaviorParameter.parameterType == (int)BehaviorParameterType.Int)
                {
                    compareEnumArr = new BehaviorCompare[] { BehaviorCompare.GREATER, BehaviorCompare.GREATER_EQUALS, BehaviorCompare.LESS_EQUAL, BehaviorCompare.LESS, BehaviorCompare.EQUALS, BehaviorCompare.NOT_EQUAL };
                }
                if (behaviorParameter.parameterType == (int)BehaviorParameterType.Float)
                {
                    compareEnumArr = new BehaviorCompare[] { BehaviorCompare.GREATER, BehaviorCompare.LESS };
                }
                if (behaviorParameter.parameterType == (int)BehaviorParameterType.Bool)
                {
                    compareEnumArr = new BehaviorCompare[] { BehaviorCompare.EQUALS, BehaviorCompare.NOT_EQUAL };
                }
                string[] compareArr = new string[compareEnumArr.Length];
                int      compare    = behaviorParameter.compare;
                bool     found      = false;
                for (int i = 0; i < compareEnumArr.Length; ++i)
                {
                    string name = System.Enum.GetName(typeof(BehaviorCompare), compareEnumArr[i]);
                    compareArr[i] = name;
                    if ((BehaviorCompare)behaviorParameter.compare == compareEnumArr[i])
                    {
                        compare = i;
                        found   = true;
                    }
                }

                if (!found)
                {
                    compare = 0;
                }

                GUI.enabled = (drawParameterType != DrawParameterType.GLOBAL_PARAMETER) && (drawParameterType != DrawParameterType.RUNTIME_PARAMETER);
                {
                    compare = EditorGUILayout.Popup(compare, compareArr, GUILayout.Width(65));
                    behaviorParameter.compare = (int)(compareEnumArr[compare]);
                }
                GUI.enabled = true;
            }
            EditorGUILayout.EndHorizontal();
            GUILayout.Space(5);

            EditorGUILayout.BeginHorizontal();
            {
                GUI.enabled = (drawParameterType != DrawParameterType.GLOBAL_PARAMETER);
                {
                    if (behaviorParameter.parameterType == (int)BehaviorParameterType.Int)
                    {
                        behaviorParameter.intValue = EditorGUILayout.IntField("DefaultIntValue", behaviorParameter.intValue);
                    }

                    if (behaviorParameter.parameterType == (int)BehaviorParameterType.Float)
                    {
                        behaviorParameter.floatValue = EditorGUILayout.FloatField("DefaultFloatValue", behaviorParameter.floatValue);
                    }

                    if (behaviorParameter.parameterType == (int)BehaviorParameterType.Bool)
                    {
                        behaviorParameter.boolValue = EditorGUILayout.Toggle("DefaultBoolValue", behaviorParameter.boolValue);
                    }
                }
                GUI.enabled = true;

                if (drawParameterType == DrawParameterType.NODE_PARAMETER || drawParameterType == DrawParameterType.GLOBAL_PARAMETER)
                {
                    if (GUILayout.Button("Del"))
                    {
                        if (null != DelCallBack)
                        {
                            DelCallBack();
                        }
                    }
                }
            }
            EditorGUILayout.EndHorizontal();

            return(behaviorParameter);
        }
Ejemplo n.º 13
0
        public static BehaviorCompare CompareString(string stringValue1, string stringValue2)
        {
            BehaviorCompare behaviorCompare = (stringValue1.CompareTo(stringValue2) == 0) ? BehaviorCompare.EQUALS : BehaviorCompare.NOT_EQUAL;

            return(behaviorCompare);
        }
Ejemplo n.º 14
0
        public static BehaviorCompare CompareBool(bool boolValue1, bool boolValue2)
        {
            BehaviorCompare behaviorCompare = (boolValue1 == boolValue2) ? BehaviorCompare.EQUALS : BehaviorCompare.NOT_EQUAL;

            return(behaviorCompare);
        }
Ejemplo n.º 15
0
        public static BehaviorParameter Draw(BehaviorParameter behaviorParameter, DrawParameterType drawParameterType, Action DelCallBack)
        {
            if (null == behaviorParameter)
            {
                return(behaviorParameter);
            }

            EditorGUILayout.BeginHorizontal();
            {
                string[] parameterNameArr = EnumNames.GetEnumNames <BehaviorParameterType>();
                int      index            = EnumNames.GetEnumIndex <BehaviorParameterType>((BehaviorParameterType)(behaviorParameter.parameterType));
                BehaviorParameterType behaviorParameterType = EnumNames.GetEnum <BehaviorParameterType>(index);

                GUI.enabled = false;
                if (drawParameterType == DrawParameterType.NODE_PARAMETER)
                {
                    EditorGUILayout.BeginHorizontal();
                    {
                        behaviorParameter.index = EditorGUILayout.IntField(behaviorParameter.index, GUILayout.Width(30));
                    }
                    EditorGUILayout.EndHorizontal();
                }

                bool enableChangeType = (drawParameterType == DrawParameterType.BEHAVIOR_PARAMETER_ADD);
                GUI.enabled = enableChangeType;
                {
                    index = EditorGUILayout.Popup(index, parameterNameArr);
                    behaviorParameter.parameterType = (int)EnumNames.GetEnum <BehaviorParameterType>(index);
                    GUILayout.Space(5);
                }
                GUI.enabled = true;

                if (drawParameterType == DrawParameterType.NODE_PARAMETER)
                {
                    GUI.enabled = false;
                    EditorGUILayout.BeginHorizontal();
                    {
                        behaviorParameter.parameterName = EditorGUILayout.TextField(behaviorParameter.parameterName);
                    }
                    EditorGUILayout.EndHorizontal();
                    GUI.enabled = true;
                }

                if (drawParameterType == DrawParameterType.NODE_PARAMETER || drawParameterType == DrawParameterType.BEHAVIOR_PARAMETER)
                {
                    if (GUILayout.Button("Del"))
                    {
                        if (null != DelCallBack)
                        {
                            DelCallBack();
                        }
                    }
                }
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.BeginHorizontal();
            {
                if (drawParameterType == DrawParameterType.NODE_PARAMETER)
                {
                    List <BehaviorParameter> parameterList = BehaviorManager.Instance.BehaviorTreeData.parameterList;
                    string[] parameterArr = new string[parameterList.Count];
                    int      index        = -1;
                    for (int i = 0; i < parameterList.Count; ++i)
                    {
                        BehaviorParameter p = parameterList[i];
                        parameterArr[i] = p.CNName;
                        if (behaviorParameter.parameterName.CompareTo(p.parameterName) == 0)
                        {
                            index = i;
                        }
                    }

                    int result = EditorGUILayout.Popup(index, parameterArr, GUILayout.ExpandWidth(true));
                    if (result != index)
                    {
                        behaviorParameter.parameterName = parameterList[result].parameterName;
                    }
                }
                else if (drawParameterType == DrawParameterType.BEHAVIOR_PARAMETER ||
                         drawParameterType == DrawParameterType.RUNTIME_PARAMETER)
                {
                    GUI.enabled = (drawParameterType == DrawParameterType.BEHAVIOR_PARAMETER_ADD);
                    behaviorParameter.parameterName = EditorGUILayout.TextField(behaviorParameter.parameterName);
                    behaviorParameter.CNName        = EditorGUILayout.TextField(behaviorParameter.CNName);
                    GUI.enabled = true;
                }
                else if (drawParameterType == DrawParameterType.BEHAVIOR_PARAMETER_ADD)
                {
                    EditorGUILayout.BeginVertical();
                    {
                        string oldName = behaviorParameter.parameterName;
                        behaviorParameter.parameterName = EditorGUILayout.TextField("英文:", behaviorParameter.parameterName);
                        if (oldName.CompareTo(behaviorParameter.parameterName) != 0)
                        {
                            bool isNumOrAlp = IsNumOrAlp(behaviorParameter.parameterName);
                            if (!isNumOrAlp)
                            {
                                string msg = string.Format("参数名只能包含:数字、字母、下划线,且数字不能放在第一个字符位置");
                                TreeNodeWindow.window.ShowNotification(msg);
                                behaviorParameter.parameterName = oldName;
                            }
                        }

                        behaviorParameter.CNName = EditorGUILayout.TextField("中文", behaviorParameter.CNName);
                    }
                    EditorGUILayout.EndVertical();
                }

                BehaviorCompare[] compareEnumArr = new BehaviorCompare[] { };
                if (behaviorParameter.parameterType == (int)BehaviorParameterType.Int)
                {
                    compareEnumArr = new BehaviorCompare[] { BehaviorCompare.GREATER, BehaviorCompare.GREATER_EQUALS, BehaviorCompare.LESS_EQUAL, BehaviorCompare.LESS, BehaviorCompare.EQUALS, BehaviorCompare.NOT_EQUAL };
                }
                if (behaviorParameter.parameterType == (int)BehaviorParameterType.Float)
                {
                    compareEnumArr = new BehaviorCompare[] { BehaviorCompare.GREATER, BehaviorCompare.LESS };
                }
                if (behaviorParameter.parameterType == (int)BehaviorParameterType.Bool)
                {
                    compareEnumArr = new BehaviorCompare[] { BehaviorCompare.EQUALS, BehaviorCompare.NOT_EQUAL };
                }
                string[] compareArr = new string[compareEnumArr.Length];
                int      compare    = behaviorParameter.compare;
                bool     found      = false;
                for (int i = 0; i < compareEnumArr.Length; ++i)
                {
                    string name = System.Enum.GetName(typeof(BehaviorCompare), compareEnumArr[i]);
                    compareArr[i] = name;
                    if ((BehaviorCompare)behaviorParameter.compare == compareEnumArr[i])
                    {
                        compare = i;
                        found   = true;
                    }
                }

                if (!found)
                {
                    compare = 0;
                }

                GUI.enabled = (drawParameterType != DrawParameterType.BEHAVIOR_PARAMETER) && (drawParameterType != DrawParameterType.RUNTIME_PARAMETER);
                bool value    = (drawParameterType != DrawParameterType.BEHAVIOR_PARAMETER) && (drawParameterType != DrawParameterType.RUNTIME_PARAMETER) && (drawParameterType != DrawParameterType.BEHAVIOR_PARAMETER_ADD);
                bool boolType = (behaviorParameter.parameterType == (int)BehaviorParameterType.Bool);
                if (value && !boolType)
                {
                    compare = EditorGUILayout.Popup(compare, compareArr, GUILayout.Width(65));
                    behaviorParameter.compare = (int)(compareEnumArr[compare]);
                }
                GUI.enabled = true;

                if (boolType)
                {
                    behaviorParameter.compare = (int)BehaviorCompare.EQUALS;
                }

                GUI.enabled = true;// (drawParameterType != DrawParameterType.BEHAVIOR_PARAMETER);
                {
                    if (behaviorParameter.parameterType == (int)BehaviorParameterType.Int)
                    {
                        behaviorParameter.intValue = EditorGUILayout.IntField(behaviorParameter.intValue, GUILayout.Width(60));
                    }

                    if (behaviorParameter.parameterType == (int)BehaviorParameterType.Float)
                    {
                        behaviorParameter.floatValue = EditorGUILayout.FloatField(behaviorParameter.floatValue, GUILayout.Width(60));
                    }

                    if (behaviorParameter.parameterType == (int)BehaviorParameterType.Bool)
                    {
                        behaviorParameter.boolValue = EditorGUILayout.Toggle(behaviorParameter.boolValue, GUILayout.Width(60));
                    }
                }
                GUI.enabled = true;
            }
            EditorGUILayout.EndHorizontal();
            GUILayout.Space(5);

            return(behaviorParameter);
        }
Ejemplo n.º 16
0
        private BehaviorCompare Compare(float value)
        {
            BehaviorCompare behaviorCompare = Compare(floatValue, value);

            return(behaviorCompare);
        }