public static bool EvaluteAssignment(Agent pAgent, Property opl, Property opr, behaviac.CMethodBase opr_m)
        {
            bool bValid = false;

            if (opl != null)
            {
                if (opr_m != null)
                {
                    object returnValue = opr_m.Invoke(pAgent);

                    Agent pParentOpl = opl.GetParentAgent(pAgent);
                    opl.SetValue(pParentOpl, returnValue);

                    bValid = true;
                }
                else if (opr != null)
                {
                    Agent pParentL = opl.GetParentAgent(pAgent);
                    Agent pParentR = opr.GetParentAgent(pAgent);

                    opl.SetFrom(pParentR, opr, pParentL);

                    bValid = true;
                }
            }

            return bValid;
        }

		protected override EBTStatus update_impl(behaviac.Agent pAgent, behaviac.EBTStatus childStatus)
		{
			Debug.Check(behaviac.Utils.MakeVariableId("par_float_type_0") == 569873069u);
			float method_p0 = pAgent.GetVariable<float>(569873069u);
			((AgentNodeTest)pAgent).setTestVar_2(method_p0);
			return EBTStatus.BT_SUCCESS;
		}

		public static object GetProperty(behaviac.Agent agent, string property)
		{
			Type type = agent.GetType();
			string propertyName = type.FullName + property;
			if (_fields.ContainsKey(propertyName))
			{
				return _fields[propertyName].GetValue(agent);
			}

			if (_properties.ContainsKey(propertyName))
			{
				return _properties[propertyName].GetValue(agent, null);
			}

			while (type != typeof(object))
			{
				FieldInfo field = type.GetField(property, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
				if (field != null)
				{
					_fields[propertyName] = field;
					return field.GetValue(agent);
				}

				PropertyInfo prop = type.GetProperty(property, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
				if (prop != null)
				{
					_properties[propertyName] = prop;
					return prop.GetValue(agent, null);
				}

				type = type.BaseType;
			}
			Debug.Check(false, "No property can be found!");
			return null;
		}

		protected override EBTStatus update_impl(behaviac.Agent pAgent, behaviac.EBTStatus childStatus)
		{
			EBTStatus result = EBTStatus.BT_SUCCESS;
			int opr = 2;
			Debug.Check(behaviac.Utils.MakeVariableId("parT_SpawnCountPerWave") == 193379536u);
			pAgent.SetVariable<int>("parT_SpawnCountPerWave", 193379536u, opr);
			return result;
		}

        protected virtual int GetWeight(behaviac.Agent pAgent)
        {
            if (this.m_weight != null)
            {
                Debug.Check(this.m_weight is CInstanceMember<int>);
                return ((CInstanceMember<int>)this.m_weight).GetValue(pAgent);
            }

            return 0;
        }

        protected virtual int GetWeight(behaviac.Agent pAgent)
        {
            if (this.m_weight_var != null)
            {
                Debug.Check(this.m_weight_var != null);
                int count = (int)this.m_weight_var.GetValue(pAgent);

                return count;
            }

            return 0;
        }

		private static void ExportMethod(Dictionary<string, Type> types, XmlWriter xmlWriter, MethodInfo m, behaviac.MethodMetaInfoAttribute methodDesc, string eventName, bool onlyExportPublicMembers)
		{
			string methodName = !string.IsNullOrEmpty(eventName) ? eventName : m.Name;

//			if (methodName == "Func_SByteListIR")
//			{
//				Debug.Check(true);
//			}

			if (!m.IsPublic)
			{
				if (!Config.IsSuppressingNonPublicWarning)
				{
					string warningInfo = string.Format("Export non-public method : {0}.{1}()", m.DeclaringType.Name, methodName);
					Debug.LogWarning(warningInfo);
				}
				
				if (onlyExportPublicMembers)
				{
					return;
				}
			}

            Type returnType = m.ReturnType;
            if (methodDesc.IsNamedEvent && returnType != typeof(bool))
            {
				string clsName = (m.DeclaringType.DeclaringType != null) ? m.DeclaringType.DeclaringType.Name : m.DeclaringType.Name;
				behaviac.Debug.LogWarning(string.Format("The return type of {0}.{1}() is not bool type", clsName, methodName));
                returnType = typeof(bool);
            }

            string returnTypeStr = GetFullTypeName(returnType);

            Type parentClassType = m.DeclaringType;
            if (methodDesc.IsNamedEvent)
            {
                parentClassType = m.DeclaringType.DeclaringType;
            }

			string parentClassTypeFullName = GetFullTypeName(parentClassType);

            if (types == null)
            {
                xmlWriter.WriteStartElement("Method");

                xmlWriter.WriteAttributeString("Name", methodName);
                xmlWriter.WriteAttributeString("DisplayName", methodDesc.DisplayName);
                xmlWriter.WriteAttributeString("Desc", methodDesc.Description);
                xmlWriter.WriteAttributeString("ReturnType", returnTypeStr);
                xmlWriter.WriteAttributeString("Class", parentClassTypeFullName);

                if (m.IsStatic)
                {
                    xmlWriter.WriteAttributeString("Static", "true");
                }
                if (m.IsPublic)
                {
                    xmlWriter.WriteAttributeString("Public", "true");
                }
                if (methodDesc.IsNamedEvent)
                {
                    xmlWriter.WriteAttributeString("Flag", "namedevent");
                }
            }

            //TODO:IsActionMethodOnly

            ParameterInfo[] parameters = m.GetParameters();

            foreach (ParameterInfo para in parameters)
            {
                Attribute[] paramAttributes = (Attribute[])para.GetCustomAttributes(typeof(behaviac.ParamMetaInfoAttribute), false);

                Type paramType = para.ParameterType;
                if (para.ParameterType.IsByRef)
                {
                    paramType = para.ParameterType.GetElementType();
                }

                string paramNativeType = GetFullTypeName(paramType);
                string paramDisplayName = para.Name;
                string paramDescription = paramDisplayName;
                string defaultValue = "";
                float rangeMin = float.MinValue;
                float rangeMax = float.MaxValue;

                if (paramAttributes.Length > 0)
                {
                    behaviac.ParamMetaInfoAttribute paramDescAttr = ((behaviac.ParamMetaInfoAttribute)paramAttributes[0]);
                    paramDisplayName = paramDescAttr.DisplayName;
                    paramDescription = paramDescAttr.Description;
                    defaultValue = paramDescAttr.DefaultValue;
                    rangeMin = paramDescAttr.RangeMin;
                    rangeMax = paramDescAttr.RangeMax;
                }

                if (para.ParameterType.IsByRef)
                {
                    paramNativeType += "&";
                }
//.........这里部分代码省略.........

 public Vector3 predicateFirePoint(behaviac.Agent target)
 {
     return Vector3.zero;
 }