Example #1
0
        // PUBLIC STAT MODIFIER METHODS: ----------------------------------------------------------

        public void AddStatModifier(StatModifier statModifier, bool informCallbacks = true)
        {
            this.RequireInit();
            if (!statModifier.stat)
            {
                Debug.LogError("AddStatModifier: Undefined Stat object");
                return;
            }

            RuntimeStatData data = this.runtimeStatsData[statModifier.stat.uniqueID];

            data.statsModifiers.Add(statModifier);
            data.statsModifiers.Sort(this.SortFunctionStatModifiers);

            if (data.onChange != null)
            {
                data.onChange.Invoke();
            }
            if (informCallbacks && this.onChangeStat != null)
            {
                this.onChangeStat.Invoke(new EventArgs(
                                             statModifier.stat.stat.uniqueName, EventArgs.Operation.Add
                                             ));
            }
            if (informCallbacks && this.onChangeAttr != null)
            {
                this.onChangeAttr.Invoke(new EventArgs(
                                             string.Empty, EventArgs.Operation.Add
                                             ));
            }
        }
Example #2
0
        public void RemoveStatModifier(StatModifier statModifier, bool informCallbacks = true)
        {
            this.RequireInit();
            if (!statModifier.stat)
            {
                Debug.LogError("RemoveStatModifier: Undefined Stat object");
                return;
            }

            RuntimeStatData data = this.runtimeStatsData[statModifier.stat.uniqueID];

            int  statModifiersCount = data.statsModifiers.Count;
            bool statModifierFound  = false;

            for (int i = 0; !statModifierFound && i < statModifiersCount; ++i)
            {
                StatModifier element = data.statsModifiers[i];
                statModifierFound = (
                    element.stat == statModifier.stat &&
                    element.type == statModifier.type &&
                    Mathf.Approximately(element.value, statModifier.value)
                    );

                if (statModifierFound)
                {
                    data.statsModifiers.RemoveAt(i);
                }
            }

            if (!statModifierFound)
            {
                return;
            }
            data.statsModifiers.Sort(this.SortFunctionStatModifiers);

            if (data.onChange != null)
            {
                data.onChange.Invoke();
            }
            if (informCallbacks && this.onChangeStat != null)
            {
                this.onChangeStat.Invoke(new EventArgs(
                                             statModifier.stat.stat.uniqueName, EventArgs.Operation.Remove
                                             ));
            }
            if (informCallbacks && this.onChangeAttr != null)
            {
                this.onChangeAttr.Invoke(new EventArgs(
                                             string.Empty, EventArgs.Operation.Remove
                                             ));
            }
        }
Example #3
0
        // PUBLIC GET METHODS: --------------------------------------------------------------------

        public float GetStat(string stat, Stats target)
        {
            this.RequireInit();
            RuntimeStatData data   = this.GetRuntimeStat(stat);
            float           result = 0.0f;

            if (data != null)
            {
                result = data.baseValue;
                if (data.formula)
                {
                    result = data.formula.formula.Calculate(
                        data.baseValue, this, target
                        );
                }

                float sumPercent = 0f;

                for (int i = 0; i < data.statsModifiers.Count; i++)
                {
                    StatModifier statModifier = data.statsModifiers[i];
                    switch (statModifier.type)
                    {
                    case StatModifier.EffectType.Contant:
                        result += statModifier.value;
                        break;

                    case StatModifier.EffectType.Percent:
                        sumPercent += (statModifier.value / 100f);
                        if (i + 1 >= data.statsModifiers.Count ||
                            data.statsModifiers[i + 1].type != StatModifier.EffectType.Percent)
                        {
                            result    *= (1.0f + sumPercent);
                            sumPercent = 0f;
                        }
                        break;
                    }
                }
            }

            return(result);
        }
Example #4
0
        // PUBLIC SET METHODS: --------------------------------------------------------------------

        public void SetStatBase(string stat, float value, bool informCallbacks = true)
        {
            this.RequireInit();
            RuntimeStatData data = this.GetRuntimeStat(stat);

            data.baseValue = value;
            if (data.onChange != null)
            {
                data.onChange.Invoke();
            }
            if (informCallbacks && this.onChangeStat != null)
            {
                this.onChangeStat.Invoke(new EventArgs(
                                             stat, EventArgs.Operation.Change
                                             ));
            }
            if (informCallbacks && this.onChangeAttr != null)
            {
                this.onChangeAttr.Invoke(new EventArgs(
                                             string.Empty, EventArgs.Operation.Change
                                             ));
            }
        }
Example #5
0
        public void MultiplyStatBase(string stat, float value, bool informCallbacks = true)
        {
            this.RequireInit();
            RuntimeStatData data = this.runtimeStatsData[STATS_TLB[stat]];

            data.baseValue *= value;

            if (data.onChange != null)
            {
                data.onChange.Invoke();
            }
            if (informCallbacks && this.onChangeStat != null)
            {
                this.onChangeStat.Invoke(new EventArgs(
                                             stat, EventArgs.Operation.Change
                                             ));
            }
            if (informCallbacks && this.onChangeAttr != null)
            {
                this.onChangeAttr.Invoke(new EventArgs(
                                             string.Empty, EventArgs.Operation.Change
                                             ));
            }
        }