float ApplyBuff(Enum statType, float value)
 {
     string strStatType = statType.ToString();
     float addSum = 0;
     float multiSum = 0;
     foreach (var buff in buffs)
     {
         if (buff.Value.statMod != null)
         {
             foreach (var buffStat in buff.Value.statMod)
             {
                 string strBuffStatType = buffStat.Key.ToString();
                 if (strBuffStatType == strStatType)
                 {
                     addSum += buffStat.Value;
                 }
                 else if (strBuffStatType != "GoldGetAmplifier" && strBuffStatType == strStatType + "Amplifier")
                 {
                     multiSum += buffStat.Value;
                 }
             }
         }
     }
     return (value + addSum) * (1 + multiSum);
 }

    /// <summary>
    /// Gets a string value for a particular enum value.
    /// </summary>
    /// <param name="value">Value.</param>
    /// <returns>String Value associated via a <see cref="StringValueAttribute"/> attribute, or null if not found.</returns>
    public static string GetStringValue(Enum value)
    {
        string output = null;
            Type type = value.GetType();

            if (_stringValues.ContainsKey(value))
                output = (_stringValues[value] as StringValueAttribute).Value;
            else
            {
                //Look for our 'StringValueAttribute' in the field's custom attributes
                FieldInfo fi = type.GetField(value.ToString());
                StringValueAttribute[] attrs = fi.GetCustomAttributes(typeof(StringValueAttribute), false) as StringValueAttribute[];
                if (attrs.Length > 0)
                {
                    try
                    {
                        _stringValues.Add(value, attrs[0]);
                    }
                    catch { }
                    output = attrs[0].Value;
                }

            }
            return output;
    }

 /// <summary>
 /// 添加事件及回调
 /// </summary>
 /// <param name="type">事件枚举</param>
 /// <param name="handle">回调</param>
 /// <param name="isUseOnce"></param>
 public static void AddEvent(Enum type, EventHandle handle, bool isUseOnce = false)
 {
     if (isUseOnce)
     {
         if (mUseOnceEventDic.ContainsKey(type))
         {
             if (!mUseOnceEventDic[type].Contains(handle))
                 mUseOnceEventDic[type].Add(handle);
             else
                 Debug.LogWarning("already existing EventType: " + type + " handle: " + handle);
         }
         else
         {
             List<EventHandle> temp = new List<EventHandle>();
             temp.Add(handle);
             mUseOnceEventDic.Add(type, temp);
         }
     }
     else
     {
         if (mEventDic.ContainsKey(type))
         {
             if (!mEventDic[type].Contains(handle))
                 mEventDic[type].Add(handle);
             else
                 Debug.LogWarning("already existing EventType: "+ type+" handle: "+ handle );
         }
         else
         {
             List<EventHandle> temp = new List<EventHandle>();
             temp.Add(handle);
             mEventDic.Add(type, temp);
         }
     }
 }

    protected void Init(Enum statType, object val)
    {
        CheckKeyType(statType);
        ClearCache();

        initValue.Add(statType, val);
    }

    IEnumerator Limp_Enter(Enum prevState)
    {
        Debug.Log("Enter Limp " + prevState.ToString());
        yield return new WaitForSeconds(5);

        Debug.Log("Limp Entered");
    }

    public float GetRatio(Enum statusKey)
    {
        Assert.IsTrue(ContainsKey(statusKey));

        var targetStatus = Find(statusKey);
        return targetStatus.Get(statusKey) / targetStatus.GetMax(statusKey);
    }

    public float Get(Enum statKey)
    {
        Type keyType = statKey.GetType();
        Assert.IsTrue(stats.ContainsKey(keyType));

        return stats[keyType].Get(statKey);
    }

        /// <summary>
        /// Initializes a new instance of the EnumItem class.
        /// </summary>
        /// <param name="document">The document that contains the element.</param>
        /// <param name="parent">The parent of the element.</param>
        /// <param name="header">The Xml header for this element.</param>
        /// <param name="attributes">The list of attributes attached to this element.</param>
        /// <param name="declaration">The declaration code for this element.</param>
        /// <param name="initialization">The initialization expression, if there is one.</param>
        /// <param name="unsafeCode">Indicates whether the element resides within a block of unsafe code.</param>
        /// <param name="generated">Indicates whether the code element was generated or written by hand.</param>
        internal EnumItem(
            CsDocument document,
            Enum parent,
            XmlHeader header,
            ICollection<Attribute> attributes,
            Declaration declaration,
            Expression initialization,
            bool unsafeCode,
            bool generated)
            : base(document,
            parent,
            ElementType.EnumItem, 
            "enum item " + declaration.Name, 
            header, 
            attributes,
            declaration,
            unsafeCode,
            generated)
        {
            Param.Ignore(document, parent, header, attributes, declaration, initialization, unsafeCode, generated);

            this.initialization = initialization;
            if (this.initialization != null)
            {
                this.AddExpression(this.initialization);
            }
        }

    public void ChangeState(Enum newState)
    {
        if(mCurrentWorkDelegate != null){
            StopCoroutine(mCurrentWorkDelegate);
        }

        if(mCurrentState != null){
            StateTransitionDelegate exitDelegate = mEndStateDelegate[mCurrentState];
            if(exitDelegate != null){
                exitDelegate();
            }
        }

        StateTransitionDelegate enterDelegate = mStartStateDelegate[newState];
        if(enterDelegate != null){
            enterDelegate();
        }

        mCurrentState = newState;

        StateWorkDelegate workDelegate = mStateWorkDelegate[mCurrentState];
        if(workDelegate != null){
            mCurrentWorkDelegate = workDelegate();
            StartCoroutine(mCurrentWorkDelegate);
        }
    }

 void Exit_EnterState()
 {
     exitSaveColor = exitStyle.normal.textColor;
     exitStyle.normal.textColor = Color.red;
     this.lastState = (Enum)stateMachine.lastState;
     this.lastMachine = stateMachine.lastStateMachineBehaviour;
 }

    public static bool HasDone(Enum check)
    {
        if (HarmonicSerialization.Instance.CurrentSave != null)
        {
            if (HarmonicSerialization.Instance.CurrentSave.HideTutorial)
                return true;
            else
            {
                if (check is MeatspaceProgress)
                    return (HarmonicSerialization.Instance.CurrentSave.MeatspaceProgression & ((MeatspaceProgress)check)) != 0;
                else if (check is CyberspaceProgress)
                    return (HarmonicSerialization.Instance.CurrentSave.CyberspaceProgression & ((CyberspaceProgress)check)) != 0;
                else if (check is WorkstationProgress)
                    return (HarmonicSerialization.Instance.CurrentSave.WorkstationProgression & ((WorkstationProgress)check)) != 0;
                else if (check is HackingProgress)
                    return (HarmonicSerialization.Instance.CurrentSave.HackingProgression & ((HackingProgress)check)) != 0;

                UnityEngine.Debug.LogWarning("flag enum is none of any progression enums!");
                return false;
            }
        }
        else
        {
            UnityEngine.Debug.LogWarning("no current save to check enums against!");
            return false;
        }
    }

 /// <summary>
 ///     Limit the display of the field based on the enum value of another field
 /// </summary>
 /// <param name="field">Field to check for enum value</param>
 /// <param name="value">Enum value other field must have</param>
 /// <param name="contains">If not contains, enums have to match exactly</param>
 /// <param name="reverse">If reversed, will only display if the other field's value does not match</param>
 public DatablockEnumAttribute(string field, object value, bool reverse = false, bool contains = false)
 {
     fieldName = field;
     enumValue = (Enum)value;
     this.reverse = reverse;
     this.contains = contains;
 }

			internal Visitor(Enum providerMode)
			{
				if(providerMode == null)
				{
					throw Error.ArgumentNull("providerMode");
				}
				this._providerMode = providerMode;
			}

 public static Enum EnumComboBox(string label, Enum selected)
 {
     EditorGUILayout.BeginHorizontal();
     GUILayout.Label(label);
     var result = EnumComboBox(selected);
     EditorGUILayout.EndHorizontal();
     return result;
 }

    public void RemoveState(Enum stateId) {
        FSMState state = GetState(stateId);

        if(state == null)
            throw new Exception("Could not find state " + stateId.ToString() + " for removal.");

        _states.Remove(state);
    }

 public bool Change(Enum statusKey, float value)
 {
     if (ContainsKey(statusKey))
     {
         Find(statusKey).Change(statusKey, value);
         return true;
     }
     return false;
 }

 Status2 Find(Enum statusKey)
 {
     Type keyType = statusKey.GetType();
     if (statuses.ContainsKey(keyType))
     {
         return statuses[keyType];
     }
     return null;
 }

		public EnumMember (Enum parent, EnumMember prev_member, string name, Expression expr,
				   Attributes attrs, Location loc)
			: base (parent, new EnumTypeExpr (parent), name, expr, Modifiers.PUBLIC,
				attrs, loc)
		{
			this.ParentEnum = parent;
			this.ValueExpr = expr;
			this.prev_member = prev_member;
		}

    public void AddEventListener(Enum EventEnum, EventHandle handle)
    {
        EventHandRegisterInfo info = new EventHandRegisterInfo();
        info.m_EventKey = EventEnum;
        info.m_hande = handle;

        GlobalEvent.AddEvent(EventEnum, handle);

        m_EventListeners.Add(info);
    }

	public static string GetEnumDescription (Enum value)
	{
		FieldInfo fi = value.GetType ().GetField (value.ToString ());
		DescriptionAttribute [] attributes =
			(DescriptionAttribute []) fi.GetCustomAttributes (typeof (DescriptionAttribute), false);
		if (attributes.Length > 0) {
			return attributes [0].Description;
		} else {
			return value.ToString ();
		}
	}