Система статов в Unity

public class Stat
{
    private float _baseValue;
    private List<Modifier> _flatModifiers = new();
    private List<Modifier> _additiveModifiers = new();
    private List<Modifier> _multiplicativeModifiers = new();
    
    // Методы добавления, удаления и расчета...
    
    private float CalculateValue()
    {
        float value = _baseValue;
        
        // Расчет плоских модификаторов
        // Расчет аддитивных модификаторов
        // Расчет мультипликативных модификаторов
        
        return value;
    }
}

public interface IModifierOperation
{
    void AddModifier(Modifier modifier);
    bool RemoveModifier(Modifier modifier);
    float CalculateModifierValue(float baseValue, float currentValue);
}
 
public class FlatModifierOperation : IModifierOperation
{
    private List<Modifier> _modifiers = new();
    
    public float CalculateModifierValue(float baseValue, float currentValue)
    {
        float result = 0;
        foreach (var modifier in _modifiers)
            result += modifier.Value;
        return result;
    }
    
    // Реализация других методов...
}

public class StatComponent : MonoBehaviour
{
    private Dictionary<StatType, Stat> _stats = new();
    
    public float GetStatValue(StatType type)
    {
        if (_stats.TryGetValue(type, out Stat stat))
            return stat.Value;
        return 0;
    }
    
    // Другие методы...
}
 
public class DamageDealer : MonoBehaviour
{
    [SerializeField] private StatType _damageStatType;
    
    public float GetDamage()
    {
        var statComponent = GetComponent<StatComponent>();
        return statComponent.GetStatValue(_damageStatType);
    }
}

[CreateAssetMenu(fileName = "New Stat Definition", menuName = "Stats/Stat Definition")]
public class StatDefinition : ScriptableObject
{
    public string StatName;
    public float DefaultValue;
    public float MinValue;
    public float MaxValue;
    public StatCalculationType CalculationType;
    // Другие параметры...
}

public class Stat
{
    public event Action<float> ValueChanged;
    
    private float _value;
    public float Value
    {
        get => _value;
        private set
        {
            if (_value != value)
            {
                _value = value;
                ValueChanged?.Invoke(_value);
            }
        }
    }
    
    // Остальная реализация...
}

public interface IModifiersOperations
{
    void AddModifier(Modifier modifier);
    bool TryRemoveModifier(Modifier modifier);
    List<Modifier> GetAllModifiers();
    float CalculateModifiersValue(float baseValue, float currentValue);
}

public abstract class ModifierOperationsBase : IModifiersOperations
{
    protected readonly List<Modifier> Modifiers;
    
    protected ModifierOperationsBase(int capacity) => Modifiers = new List<Modifier>(capacity);
    protected ModifierOperationsBase() => Modifiers = new List<Modifier>(4);
    
    public virtual void AddModifier(Modifier modifier)
    {
        CheckListCapacity(Modifiers, modifier.Type);
        Modifiers.Add(modifier);
    }
    
    public virtual bool TryRemoveModifier(Modifier modifier) => Modifiers.Remove(modifier);
    
    public virtual List<Modifier> GetAllModifiers() => Modifiers;
    
    public abstract float CalculateModifiersValue(float baseValue, float currentValue);
    
    // Вспомогательные методы...
}

public sealed class FlatModifierOperations : ModifierOperationsBase
{
    public FlatModifierOperations(int capacity) : base(capacity) { }
    
    public override float CalculateModifiersValue(float baseValue, float currentValue)
    {
        float flatModifiersSum = 0f;
        
        for (var i = 0; i < Modifiers.Count; i++)
            flatModifiersSum += Modifiers[i];
        
        return flatModifiersSum;
    }
}
 
public sealed class AdditiveModifierOperations : ModifierOperationsBase
{
    public AdditiveModifierOperations(int capacity) : base(capacity) { }
    
    public override float CalculateModifiersValue(float baseValue, float currentValue)
    {
        float additiveModifiersSum = 0f;
        
        for (var i = 0; i < Modifiers.Count; i++)
            additiveModifiersSum += Modifiers[i];
        
        return baseValue * additiveModifiersSum;
    }
}
 
public sealed class MultiplicativeModifierOperations : ModifierOperationsBase
{
    public MultiplicativeModifierOperations(int capacity) : base(capacity) { }
    
    public override float CalculateModifiersValue(float baseValue, float currentValue)
    {
        float calculatedValue = currentValue;
        
        for (var i = 0; i < Modifiers.Count; i++)
            calculatedValue += calculatedValue * Modifiers[i];
        
        return calculatedValue - currentValue;
    }
}

internal sealed class ModifierOperationsCollection
{
    private readonly Dictionary<ModifierType, Func<IModifiersOperations>> _modifierOperationsDict = new();
    private bool _modifiersCollectionHasBeenReturned;
    
    internal ModifierType AddModifierOperation(int order, Func<IModifiersOperations> modifierOperationsDelegate)
    {
        if (_modifiersCollectionHasBeenReturned)
            throw new InvalidOperationException("Cannot change collection after it has been returned");
        
        var modifierType = (ModifierType)order;
        
        if (modifierType is ModifierType.Flat or ModifierType.Additive or ModifierType.Multiplicative)
            Debug.LogWarning("Modifier operations for types flat, additive and multiplicative cannot be changed!");
        
        _modifierOperationsDict[modifierType] = modifierOperationsDelegate;
        
        return modifierType;
    }
    
    internal Dictionary<ModifierType, Func<IModifiersOperations>> GetModifierOperations(int capacity)
    {
        _modifierOperationsDict[ModifierType.Flat] = () => new FlatModifierOperations(capacity);
        _modifierOperationsDict[ModifierType.Additive] = () => new AdditiveModifierOperations(capacity);
        _modifierOperationsDict[ModifierType.Multiplicative] = () => new MultiplicativeModifierOperations(capacity);
        
        _modifiersCollectionHasBeenReturned = true;
        
        return _modifierOperationsDict;
    }
}

[Serializable]
public sealed class Stat
{
    private const int DEFAULT_LIST_CAPACITY = 4;
    private const int DEFAULT_DIGIT_ACCURACY = 2;
    internal const int MAXIMUM_ROUND_DIGITS = 8;
    
    [SerializeField] private float baseValue;
    
    private static ModifierOperationsCollection _ModifierOperationsCollection = new();
    
    private readonly int _digitAccuracy;
    private readonly List<Modifier> _modifiersList = new();
    private readonly SortedList<ModifierType, IModifiersOperations> _modifiersOperations = new();
    
    private float _currentValue;
    private bool _isDirty;
    
    public Stat(float baseValue, int digitAccuracy, int modsMaxCapacity)
    {
        this.baseValue = baseValue;
        _currentValue = baseValue;
        _digitAccuracy = digitAccuracy;
        
        InitializeModifierOperations(modsMaxCapacity);
        
        void InitializeModifierOperations(int capacity)
        {
            var modifierOperations = _ModifierOperationsCollection.GetModifierOperations(capacity);
            
            foreach (var operationType in modifierOperations.Keys)
                _modifiersOperations[operationType] = modifierOperations[operationType]();
        }
    }
    
    // Конструкторы и свойства...
    
    public void AddModifier(Modifier modifier)
    {
        IsDirty = true;
        _modifiersOperations[modifier.Type].AddModifier(modifier);
    }
    
    public static ModifierType NewModifierType(int order, Func<IModifiersOperations> modifierOperationsDelegate)
    {
        try
        {
            return _ModifierOperationsCollection.AddModifierOperation(order, modifierOperationsDelegate);
        }
        catch
        {
            throw new InvalidOperationException("Add any modifier operations before any initialization of the Stat class!");
        }
    }
    
    // Другие методы...
    
    private float CalculateModifiedValue(int digitAccuracy)
    {
        digitAccuracy = Math.Clamp(digitAccuracy, 0, MAXIMUM_ROUND_DIGITS);
        
        float finalValue = baseValue;
        
        for (int i = 0; i < _modifiersOperations.Count; i++)
            finalValue += _modifiersOperations.Values[i].CalculateModifiersValue(baseValue, finalValue);
        
        IsDirty = false;
        
        return (float)Math.Round(finalValue, digitAccuracy);
    }
}

[Serializable]
public class StatDefinition
{
    public string StatKey; // Ключ для локализации
    public float BaseValue;
    public StatFormat DisplayFormat; // Формат отображения (абсолютный, процентный)
    
    // Другие параметры...
}
 
public enum StatFormat
{
    Absolute,
    Percentage,
    Integer,
    Time
}

public class StatChangeEvent
{
    public StatType Type { get; }
    public float OldValue { get; }
    public float NewValue { get; }
    
    public StatChangeEvent(StatType type, float oldValue, float newValue)
    {
        Type = type;
        OldValue = oldValue;
        NewValue = newValue;
    }
}
 
public interface IStatEventListener
{
    void OnStatChanged(StatChangeEvent e);
}

public readonly struct Modifier
{
    public ModifierType Type { get; }
    public object Source { get; }
 
    private readonly float _value;
 
    public Modifier(float value, ModifierType modifierType, object source = null)
    {
        _value = value;
        Type = modifierType;
        Source = source;
    }
 
    public static implicit operator float(Modifier modifier) => modifier._value;
}

[Serializable]
public sealed class Stat
{
    [SerializeField] private float baseValue;
 
    private readonly int _digitAccuracy;
    private readonly SortedList<ModifierType, IModifiersOperations> _modifiersOperations;
    
    private float _currentValue;
    private bool _isDirty;
 
    public event Action ValueChanged;
    public event Action ModifiersChanged;
 
    public Stat(float baseValue, int digitAccuracy = 2, int capacity = 4)
    {
        this.baseValue = baseValue;
        _currentValue = baseValue;
        _digitAccuracy = digitAccuracy;
        
        _modifiersOperations = new SortedList<ModifierType, IModifiersOperations>();
        InitializeModifierOperations(capacity);
    }
 
    public float Value
    {
        get
        {
            if (IsDirty)
            {
                _currentValue = CalculateModifiedValue(_digitAccuracy);
                OnValueChanged();
            }
            return _currentValue;
        }
    }
 
    // Остальная реализация...
}

private float CalculateModifiedValue(int digitAccuracy)
{
    float finalValue = baseValue;
    
    foreach (var operation in _modifiersOperations.Values)
        finalValue += operation.CalculateModifiersValue(baseValue, finalValue);
    
    IsDirty = false;
    
    return (float)Math.Round(finalValue, digitAccuracy);
}

private bool IsDirty
{
    get => _isDirty;
    set
    {
        _isDirty = value;
        if (_isDirty)
            OnModifiersChanged();
    }
}
 
private void OnValueChanged() => ValueChanged?.Invoke();
private void OnModifiersChanged() => ModifiersChanged?.Invoke();

public class HealthBar : MonoBehaviour
{
    [SerializeField] private Image fillImage;
    [SerializeField] private StatComponent statComponent;
    [SerializeField] private StatType healthStatType;
 
    private void Start()
    {
        var healthStat = statComponent.GetStat(healthStatType);
        healthStat.ValueChanged += UpdateHealthBar;
        UpdateHealthBar(); // Инициализация
    }
 
    private void UpdateHealthBar()
    {
        var healthStat = statComponent.GetStat(healthStatType);
        fillImage.fillAmount = healthStat.Value / healthStat.MaxValue;
    }
 
    private void OnDestroy()
    {
        var healthStat = statComponent.GetStat(healthStatType);
        healthStat.ValueChanged -= UpdateHealthBar;
    }
}

public class DerivedStat : Stat
{
    private readonly List<Stat> _dependentStats = new();
    private readonly Func<float> _calculateBaseValue;
 
    public DerivedStat(Func<float> baseValueCalculator, int digitAccuracy = 2, int capacity = 4)
        : base(0, digitAccuracy, capacity)
    {
        _calculateBaseValue = baseValueCalculator;
    }
 
    public void AddDependency(Stat stat)
    {
        _dependentStats.Add(stat);
        stat.ValueChanged += MarkDirty;
        MarkDirty();
    }
 
    public void RemoveDependency(Stat stat)
    {
        if (_dependentStats.Remove(stat))
        {
            stat.ValueChanged -= MarkDirty;
            MarkDirty();
        }
    }
 
    public override float BaseValue
    {
        get => _calculateBaseValue();
    }
 
    private void MarkDirty() => IsDirty = true;
 
    protected override void OnDispose()
    {
        foreach (var stat in _dependentStats)
            stat.ValueChanged -= MarkDirty;
        
        base.OnDispose();
    }
}

var strength = new Stat(10);
var health = new DerivedStat(() => 50 + strength.Value * 5);
health.AddDependency(strength);

public class VersionedStat : Stat
{
    private int _version = 0;
    private readonly Dictionary<int, float> _cachedValues = new();
 
    public float GetValueForLevel(int level)
    {
        if (_cachedValues.TryGetValue(level, out float value) && !IsDirty)
            return value;
        
        value = CalculateValueForLevel(level);
        _cachedValues[level] = value;
        return value;
    }
 
    public void InvalidateCache()
    {
        _version++;
        _cachedValues.Clear();
        IsDirty = true;
    }
 
    protected virtual float CalculateValueForLevel(int level)
    {
        return BaseValue * (1 + 0.1f * level);
    }
}

public class ClampedStat : Stat
{
    private readonly float _minValue;
    private readonly float _maxValue;
 
    public ClampedStat(float baseValue, float minValue, float maxValue, int digitAccuracy = 2, int capacity = 4)
        : base(baseValue, digitAccuracy, capacity)
    {
        _minValue = minValue;
        _maxValue = maxValue;
    }
 
    public override float Value
    {
        get => Mathf.Clamp(base.Value, _minValue, _maxValue);
    }
}

public class InterceptableStat : Stat
{
    private readonly List<Func<float, float>> _valueInterceptors = new();
 
    public void AddInterceptor(Func<float, float> interceptor)
    {
        _valueInterceptors.Add(interceptor);
        IsDirty = true;
    }
 
    public void RemoveInterceptor(Func<float, float> interceptor)
    {
        if (_valueInterceptors.Remove(interceptor))
            IsDirty = true;
    }
 
    public override float Value
    {
        get
        {
            float value = base.Value;
            foreach (var interceptor in _valueInterceptors)
                value = interceptor(value);
            return value;
        }
    }
}

var damageStat = new InterceptableStat(10);
 
// Добавление перехватчика для критического урона
bool isCritical = Random.value < 0.2f;
if (isCritical)
    damageStat.AddInterceptor(damage => damage * 2);
 
// Временная неуязвимость
character.AddInterceptor(damage => 0);
StartCoroutine(RemoveInvulnerabilityAfterDelay(character, 2f));

public class BaseAbsoluteReductionModifierOperations : ModifierOperationsBase
{
    public BaseAbsoluteReductionModifierOperations(int capacity) : base(capacity) { }
    
    public override float CalculateModifiersValue(float baseValue, float currentValue)
    {
        var biggestModifier = 0f;
        
        for (var i = 0; i < Modifiers.Count; i++)
            biggestModifier = Mathf.Max(biggestModifier, Modifiers[i]);
        
        var modifierValue = biggestModifier == 0f ? 0f : baseValue * (1 - biggestModifier) - currentValue;
        
        return modifierValue;
    }
}

var BaseAbsoluteReduction = Stat.NewModifierType(400, () => new BaseAbsoluteReductionModifierOperations());

var strengthStat = new Stat(100);
var strengthCurse = new Modifier(0.2f, BaseAbsoluteReduction, source: curseItem);
strengthStat.AddModifier(strengthCurse);

public class StatController : MonoBehaviour
{
    [Serializable]
    private class StatDefinition
    {
        public StatType Type;
        public float BaseValue;
        public int Precision = 2;
        public int Capacity = 4;
    }
    
    [SerializeField] private StatDefinition[] statDefinitions;
    
    private Dictionary<StatType, Stat> _stats = new();
    
    private void Awake()
    {
        foreach (var definition in statDefinitions)
        {
            _stats[definition.Type] = new Stat(definition.BaseValue, definition.Precision, definition.Capacity);
        }
    }
    
    public Stat GetStat(StatType type)
    {
        if (_stats.TryGetValue(type, out var stat))
            return stat;
            
        Debug.LogWarning($"Stat of type {type} not found on {gameObject.name}");
        return null;
    }
    
    public bool TryStat(StatType type, out Stat stat)
    {
        return _stats.TryGetValue(type, out stat);
    }
}

[CustomEditor(typeof(StatController))]
public class StatControllerEditor : Editor
{
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();
        
        if (Application.isPlaying)
        {
            EditorGUILayout.Space();
            EditorGUILayout.LabelField("Current Values", EditorStyles.boldLabel);
            
            var controller = (StatController)target;
            var stats = new List<StatType>(Enum.GetValues(typeof(StatType)) as StatType[]);
            
            foreach (var type in stats)
            {
                if (controller.TryStat(type, out var stat))
                {
                    EditorGUILayout.LabelField($"{type}: {stat.Value}");
                }
            }
        }
    }
}

public class DerivedStatController : MonoBehaviour
{
    [Serializable]
    private class DerivedStatDefinition
    {
        public StatType Type;
        public StatType[] DependsOn;
        public string Formula;
        public int Precision = 2;
        public int Capacity = 4;
    }
    
    [SerializeField] private DerivedStatDefinition[] derivedStats;
    [SerializeField] private StatController statController;
    
    private Dictionary<StatType, DerivedStat> _derivedStats = new();
    private Dictionary<string, Func<float[], float>> _formulas = new Dictionary<string, Func<float[], float>>()
    {
        {"sum", values => values.Sum()},
        {"product", values => values.Aggregate(1f, (a, b) => a * b)},
        {"max", values => values.Max()},
        {"min", values => values.Min()},
        {"health", values => 50 + values[0] * 5}, // Предполагается, что первый стат - выносливость
        {"mana", values => 30 + values[0] * 3},   // Предполагается, что первый стат - интеллект
    };
    
    private void Start()
    {
        foreach (var definition in derivedStats)
        {
            var dependentStats = new List<Stat>();
            foreach (var dependency in definition.DependsOn)
            {
                dependentStats.Add(statController.GetStat(dependency));
            }
            
            var formula = _formulas[definition.Formula];
            var derivedStat = new DerivedStat(() => 
            {
                var values = dependentStats.Select(s => s.Value).ToArray();
                return formula(values);
            }, definition.Precision, definition.Capacity);
            
            foreach (var stat in dependentStats)
            {
                derivedStat.AddDependency(stat);
            }
            
            _derivedStats[definition.Type] = derivedStat;
        }
    }
    
    public Stat GetStat(StatType type)
    {
        if (_derivedStats.TryGetValue(type, out var stat))
            return stat;
            
        return null;
    }
}

public class TemporaryEffectManager : MonoBehaviour
{
    private class TemporaryEffect
    {
        public Stat TargetStat;
        public Modifier AppliedModifier;
        public float RemainingDuration;
        public Action OnExpired;
 
        public TemporaryEffect(Stat targetStat, Modifier modifier, float duration, Action onExpired = null)
        {
            TargetStat = targetStat;
            AppliedModifier = modifier;
            RemainingDuration = duration;
            OnExpired = onExpired;
        }
    }
 
    private List<TemporaryEffect> _activeEffects = new();
 
    public void ApplyTemporaryEffect(Stat targetStat, Modifier modifier, float duration, Action onExpired = null)
    {
        targetStat.AddModifier(modifier);
        _activeEffects.Add(new TemporaryEffect(targetStat, modifier, duration, onExpired));
    }
 
    private void Update()
    {
        for (int i = _activeEffects.Count - 1; i >= 0; i--)
        {
            var effect = _activeEffects[i];
            effect.RemainingDuration -= Time.deltaTime;
 
            if (effect.RemainingDuration <= 0)
            {
                effect.TargetStat.TryRemoveModifier(effect.AppliedModifier);
                effect.OnExpired?.Invoke();
                _activeEffects.RemoveAt(i);
            }
        }
    }
}

var strengthBuff = new Modifier(10, ModifierType.Flat, source: potion);
effectManager.ApplyTemporaryEffect(character.GetStat(StatType.Strength), strengthBuff, 30f, 
    () => characterFeedback.ShowMessage("Действие зелья силы закончилось"));

public void ApplyTemporaryEffectWithResistance(Stat targetStat, Modifier baseModifier, float baseDuration, 
    float resistanceValue, Action onExpired = null)
{
    if (Random.value < resistanceValue)
    {
        // Эффект полностью сопротивлен
        return;
    }
 
    // Уменьшаем силу эффекта пропорционально сопротивляемости
    float modifiedValue = baseModifier.Value * (1 - resistanceValue * 0.5f);
    var modifiedModifier = new Modifier(modifiedValue, baseModifier.Type, baseModifier.Source);
 
    // Уменьшаем длительность пропорционально сопротивляемости
    float modifiedDuration = baseDuration * (1 - resistanceValue * 0.3f);
 
    ApplyTemporaryEffect(targetStat, modifiedModifier, modifiedDuration, onExpired);
}

public enum StatusEffectType
{
    Stun,
    Silence,
    Root,
    Invisible,
    Invulnerable
}
 
public class StatusEffectManager : MonoBehaviour
{
    private Dictionary<StatusEffectType, float> _activeStatusEffects = new();
    
    public bool HasStatusEffect(StatusEffectType type) => _activeStatusEffects.ContainsKey(type);
    
    public void ApplyStatusEffect(StatusEffectType type, float duration)
    {
        if (_activeStatusEffects.TryGetValue(type, out float currentDuration))
        {
            _activeStatusEffects[type] = Mathf.Max(currentDuration, duration);
        }
        else
        {
            _activeStatusEffects[type] = duration;
            OnStatusEffectApplied(type);
        }
    }
    
    private void Update()
    {
        var keys = new List<StatusEffectType>(_activeStatusEffects.Keys);
        
        foreach (var key in keys)
        {
            _activeStatusEffects[key] -= Time.deltaTime;
            
            if (_activeStatusEffects[key] <= 0)
            {
                _activeStatusEffects.Remove(key);
                OnStatusEffectRemoved(key);
            }
        }
    }
    
    protected virtual void OnStatusEffectApplied(StatusEffectType type) { }
    protected virtual void OnStatusEffectRemoved(StatusEffectType type) { }
}

[Serializable]
public class StatSaveData
{
    public StatType Type;
    public float BaseValue;
    public List<ModifierSaveData> Modifiers = new();
}
 
[Serializable]
public class ModifierSaveData
{
    public float Value;
    public ModifierType Type;
    public string SourceId; // Идентификатор источника для восстановления ссылки
}
 
public class StatSaveSystem
{
    public List<StatSaveData> SaveStats(Dictionary<StatType, Stat> stats)
    {
        var saveData = new List<StatSaveData>();
        
        foreach (var pair in stats)
        {
            var statData = new StatSaveData
            {
                Type = pair.Key,
                BaseValue = pair.Value.BaseValue
            };
            
            foreach (var modifier in pair.Value.GetModifiers())
            {
                if (modifier.Source is IIdentifiable identifiable)
                {
                    statData.Modifiers.Add(new ModifierSaveData
                    {
                        Value = modifier,
                        Type = modifier.Type,
                        SourceId = identifiable.Id
                    });
                }
            }
            
            saveData.Add(statData);
        }
        
        return saveData;
    }
    
    public void LoadStats(List<StatSaveData> saveData, Dictionary<StatType, Stat> stats, 
        Func<string, object> sourceResolver)
    {
        foreach (var statData in saveData)
        {
            if (stats.TryGetValue(statData.Type, out var stat))
            {
                stat.BaseValue = statData.BaseValue;
                
                foreach (var modData in statData.Modifiers)
                {
                    var source = sourceResolver(modData.SourceId);
                    var modifier = new Modifier(modData.Value, modData.Type, source);
                    stat.AddModifier(modifier);
                }
            }
        }
    }
}

public class StatVisualFeedback : MonoBehaviour
{
    [SerializeField] private StatController statController;
    [SerializeField] private GameObject buffEffectPrefab;
    [SerializeField] private GameObject debuffEffectPrefab;
    
    private Dictionary<StatType, float> _previousValues = new();
    
    private void Start()
    {
        foreach (StatType type in Enum.GetValues(typeof(StatType)))
        {
            if (statController.TryStat(type, out Stat stat))
            {
                _previousValues[type] = stat.Value;
                stat.ValueChanged += () => OnStatChanged(type, stat);
            }
        }
    }
    
    private void OnStatChanged(StatType type, Stat stat)
    {
        float previousValue = _previousValues[type];
        float newValue = stat.Value;
        
        if (newValue > previousValue)
        {
            ShowBuffEffect(type, newValue - previousValue);
        }
        else if (newValue < previousValue)
        {
            ShowDebuffEffect(type, previousValue - newValue);
        }
        
        _previousValues[type] = newValue;
    }
    
    private void ShowBuffEffect(StatType type, float amount)
    {
        var effect = Instantiate(buffEffectPrefab, transform.position + Vector3.up, Quaternion.identity);
        effect.GetComponent<FloatingText>().SetText($"+{amount} {type}");
    }
    
    private void ShowDebuffEffect(StatType type, float amount)
    {
        var effect = Instantiate(debuffEffectPrefab, transform.position + Vector3.up, Quaternion.identity);
        effect.GetComponent<FloatingText>().SetText($"-{amount} {type}");
    }
}

public class StatThresholdTrigger : MonoBehaviour
{
    [Serializable]
    public class Threshold
    {
        public float Value;
        public bool IsPercentage;
        public UnityEvent OnCrossedDown;
        public UnityEvent OnCrossedUp;
        [HideInInspector] public bool IsActive;
    }
    
    [SerializeField] private StatController statController;
    [SerializeField] private StatType monitoredStatType;
    [SerializeField] private List<Threshold> thresholds = new();
    
    private Stat _monitoredStat;
    
    private void Start()
    {
        _monitoredStat = statController.GetStat(monitoredStatType);
        _monitoredStat.ValueChanged += CheckThresholds;
        CheckThresholds(); // Проверка начальных значений
    }
    
    private void CheckThresholds()
    {
        float currentValue = _monitoredStat.Value;
        float maxValue = _monitoredStat is ClampedStat clampedStat ? clampedStat.MaxValue : float.MaxValue;
        
        foreach (var threshold in thresholds)
        {
            float thresholdValue = threshold.IsPercentage ? maxValue * threshold.Value / 100 : threshold.Value;
            
            if (currentValue <= thresholdValue && !threshold.IsActive)
            {
                threshold.IsActive = true;
                threshold.OnCrossedDown?.Invoke();
            }
            else if (currentValue > thresholdValue && threshold.IsActive)
            {
                threshold.IsActive = false;
                threshold.OnCrossedUp?.Invoke();
            }
        }
    }
}

[CustomEditor(typeof(StatDefinitionCollection))]
public class StatDefinitionEditor : Editor
{
    private SerializedProperty _statDefinitions;
    private int _selectedDefinitionIndex = -1;
    private bool _showAdvancedOptions = false;
 
    private void OnEnable()
    {
        _statDefinitions = serializedObject.FindProperty("statDefinitions");
    }
 
    public override void OnInspectorGUI()
    {
        serializedObject.Update();
 
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.LabelField("Доступные статы", EditorStyles.boldLabel);
        if (GUILayout.Button("Добавить стат", GUILayout.Width(100)))
        {
            _statDefinitions.arraySize++;
            _selectedDefinitionIndex = _statDefinitions.arraySize - 1;
        }
        EditorGUILayout.EndHorizontal();
 
        EditorGUILayout.Space();
 
        // Отображение списка статов
        for (int i = 0; i < _statDefinitions.arraySize; i++)
        {
            SerializedProperty statDef = _statDefinitions.GetArrayElementAtIndex(i);
            SerializedProperty nameProperty = statDef.FindPropertyRelative("name");
            
            EditorGUILayout.BeginHorizontal("box");
            
            if (GUILayout.Button(i == _selectedDefinitionIndex ? "▼" : "►", GUILayout.Width(20)))
                _selectedDefinitionIndex = i == _selectedDefinitionIndex ? -1 : i;
                
            EditorGUILayout.PropertyField(nameProperty, GUIContent.none);
            
            if (GUILayout.Button("×", GUILayout.Width(20)))
            {
                _statDefinitions.DeleteArrayElementAtIndex(i);
                serializedObject.ApplyModifiedProperties();
                return;
            }
            
            EditorGUILayout.EndHorizontal();
 
            // Отображение детальных настроек выбранного стата
            if (i == _selectedDefinitionIndex)
            {
                EditorGUI.indentLevel++;
                
                SerializedProperty baseValueProperty = statDef.FindPropertyRelative("baseValue");
                SerializedProperty minValueProperty = statDef.FindPropertyRelative("minValue");
                SerializedProperty maxValueProperty = statDef.FindPropertyRelative("maxValue");
                SerializedProperty formatProperty = statDef.FindPropertyRelative("displayFormat");
                
                EditorGUILayout.PropertyField(baseValueProperty, new GUIContent("Базовое значение"));
                EditorGUILayout.PropertyField(minValueProperty, new GUIContent("Минимум"));
                EditorGUILayout.PropertyField(maxValueProperty, new GUIContent("Максимум"));
                EditorGUILayout.PropertyField(formatProperty, new GUIContent("Формат отображения"));
                
                _showAdvancedOptions = EditorGUILayout.Foldout(_showAdvancedOptions, "Расширенные настройки");
                
                if (_showAdvancedOptions)
                {
                    SerializedProperty modifiersProperty = statDef.FindPropertyRelative("allowedModifiers");
                    EditorGUILayout.PropertyField(modifiersProperty, new GUIContent("Доступные модификаторы"), true);
                    
                    SerializedProperty dependenciesProperty = statDef.FindPropertyRelative("dependencies");
                    EditorGUILayout.PropertyField(dependenciesProperty, new GUIContent("Зависимости"), true);
                }
                
                EditorGUI.indentLevel--;
            }
        }
 
        serializedObject.ApplyModifiedProperties();
    }
}

public class StatDependencyGraph : EditorWindow
{
    private StatDefinitionCollection _statCollection;
    private Dictionary<string, Rect> _nodePositions = new Dictionary<string, Rect>();
    private Vector2 _offset;
    private Vector2 _dragStartPos;
 
    [MenuItem("Tools/Stat System/Dependency Graph")]
    public static void ShowWindow()
    {
        GetWindow<StatDependencyGraph>("Граф зависимостей статов");
    }
 
    private void OnGUI()
    {
        if (_statCollection == null)
        {
            EditorGUILayout.HelpBox("Выберите коллекцию статов для отображения", MessageType.Info);
            
            if (GUILayout.Button("Загрузить коллекцию"))
            {
                _statCollection = EditorGUIUtility.Load("StatDefinitions") as StatDefinitionCollection;
                InitializeGraph();
            }
            
            return;
        }
 
        // Обработка событий перетаскивания
        HandleDragEvents();
 
        // Отрисовка связей между статами
        DrawConnections();
 
        // Отрисовка узлов графа
        DrawNodes();
    }
 
    private void InitializeGraph()
    {
        // Инициализация позиций узлов
        float x = 50, y = 50;
        
        foreach (var statDef in _statCollection.statDefinitions)
        {
            _nodePositions[statDef.name] = new Rect(x, y, 120, 50);
            x += 150;
            
            if (x > position.width - 150)
            {
                x = 50;
                y += 100;
            }
        }
    }
 
    private void DrawNodes()
    {
        GUIStyle nodeStyle = new GUIStyle(GUI.skin.window);
        
        BeginWindows();
        
        for (int i = 0; i < _statCollection.statDefinitions.Length; i++)
        {
            var statDef = _statCollection.statDefinitions[i];
            
            if (_nodePositions.TryGetValue(statDef.name, out Rect nodeRect))
            {
                _nodePositions[statDef.name] = GUI.Window(i, nodeRect, WindowFunction, statDef.name, nodeStyle);
            }
        }
        
        EndWindows();
    }
 
    private void WindowFunction(int id)
    {
        var statDef = _statCollection.statDefinitions[id];
        
        GUILayout.Label($"База: {statDef.baseValue}");
        GUILayout.Label($"Мин/Макс: {statDef.minValue}/{statDef.maxValue}");
        
        GUI.DragWindow();
    }
 
    private void DrawConnections()
    {
        Handles.BeginGUI();
        
        foreach (var statDef in _statCollection.statDefinitions)
        {
            if (statDef.dependencies != null && statDef.dependencies.Length > 0)
            {
                if (_nodePositions.TryGetValue(statDef.name, out Rect targetRect))
                {
                    Vector3 targetPos = new Vector3(targetRect.x + targetRect.width / 2, targetRect.y + targetRect.height / 2, 0);
                    
                    foreach (var dependency in statDef.dependencies)
                    {
                        if (_nodePositions.TryGetValue(dependency, out Rect sourceRect))
                        {
                            Vector3 sourcePos = new Vector3(sourceRect.x + sourceRect.width / 2, sourceRect.y + sourceRect.height / 2, 0);
                            
                            Handles.DrawBezier(
                                sourcePos, targetPos,
                                sourcePos + Vector3.down * 50, targetPos + Vector3.up * 50,
                                Color.gray, null, 2f);
                        }
                    }
                }
            }
        }
        
        Handles.EndGUI();
    }
 
    private void HandleDragEvents()
    {
        if (Event.current.type == EventType.MouseDown && Event.current.button == 1)
        {
            _dragStartPos = Event.current.mousePosition;
            _offset = Vector2.zero;
            Event.current.Use();
        }
        else if (Event.current.type == EventType.MouseDrag && Event.current.button == 1)
        {
            _offset = Event.current.mousePosition - _dragStartPos;
            
            foreach (var key in _nodePositions.Keys.ToList())
            {
                var rect = _nodePositions[key];
                rect.position += _offset;
                _nodePositions[key] = rect;
            }
            
            _dragStartPos = Event.current.mousePosition;
            Repaint();
            Event.current.Use();
        }
    }
}

public class ItemGenerator : MonoBehaviour
{
    [Serializable]
    public class StatRangeByLevel
    {
        public AnimationCurve ValueMinCurve = AnimationCurve.Linear(0, 1, 100, 100);
        public AnimationCurve ValueMaxCurve = AnimationCurve.Linear(0, 5, 100, 500);
        public float RarityMultiplier = 1.5f;
    }
 
    [SerializeField] private Dictionary<StatType, StatRangeByLevel> _statRanges = new();
    [SerializeField] private List<ModifierType> _availableModifierTypes = new();
    [SerializeField] private AnimationCurve _modifierCountByRarityCurve = AnimationCurve.Linear(0, 1, 5, 5);
 
    public Item GenerateItem(ItemType type, int playerLevel, float rarity)
    {
        // Ограничиваем редкость в диапазоне [0, 1]
        rarity = Mathf.Clamp01(rarity);
        
        // Определяем количество модификаторов на основе редкости
        int modifierCount = Mathf.RoundToInt(_modifierCountByRarityCurve.Evaluate(rarity));
        
        // Создаем основу предмета
        Item item = new Item
        {
            Type = type,
            Level = Mathf.Max(1, playerLevel - 5 + Mathf.RoundToInt(rarity * 10)),
            Rarity = rarity,
            Name = GenerateItemName(type, rarity)
        };
        
        // Список возможных статов для данного типа предмета
        List<StatType> availableStats = GetAvailableStatsForItemType(type);
        
        // Случайный выбор статов для данного предмета (без повторений)
        List<StatType> selectedStats = SelectRandomStats(availableStats, modifierCount);
        
        // Генерация значений для выбранных статов
        foreach (var statType in selectedStats)
        {
            if (_statRanges.TryGetValue(statType, out var statRange))
            {
                // Определяем диапазон значений в зависимости от уровня
                float minValue = statRange.ValueMinCurve.Evaluate(item.Level);
                float maxValue = statRange.ValueMaxCurve.Evaluate(item.Level);
                
                // Применяем множитель редкости
                float rarityMultiplier = 1 + (rarity * (statRange.RarityMultiplier - 1));
                maxValue *= rarityMultiplier;
                
                // Генерируем значение стата
                float statValue = UnityEngine.Random.Range(minValue, maxValue);
                
                // Выбираем тип модификатора (плоский, аддитивный, мультипликативный и т.д.)
                ModifierType modifierType = SelectModifierTypeForStat(statType);
                
                // Добавляем модификатор к предмету
                item.StatModifiers.Add(new ItemStatModifier
                {
                    Type = statType,
                    ModifierType = modifierType,
                    Value = statValue
                });
            }
        }
        
        return item;
    }
 
    private string GenerateItemName(ItemType type, float rarity)
    {
        // Генерация имени в зависимости от типа и редкости предмета
        // Здесь может быть сложная логика с прилагательными и суффиксами
        
        string prefix = GetRarityPrefix(rarity);
        string baseName = GetItemBaseName(type);
        string suffix = rarity > 0.7f ? GetMagicalSuffix() : "";
        
        return string.Join(" ", new[] { prefix, baseName, suffix }.Where(s => !string.IsNullOrEmpty(s)));
    }
 
    private List<StatType> GetAvailableStatsForItemType(ItemType type)
    {
        // Каждый тип предмета может иметь свой набор возможных статов
        switch (type)
        {
            case ItemType.Weapon:
                return new List<StatType> { StatType.Damage, StatType.AttackSpeed, StatType.CritChance };
            case ItemType.Armor:
                return new List<StatType> { StatType.Defense, StatType.Health, StatType.ElementalResistance };
            case ItemType.Accessory:
                return new List<StatType> { StatType.MagicPower, StatType.CooldownReduction, StatType.MovementSpeed };
            default:
                return new List<StatType>();
        }
    }
 
    private List<StatType> SelectRandomStats(List<StatType> availableStats, int count)
    {
        // Выбираем случайные статы без повторений
        count = Mathf.Min(count, availableStats.Count);
        
        List<StatType> result = new List<StatType>();
        List<StatType> pool = new List<StatType>(availableStats);
        
        for (int i = 0; i < count; i++)
        {
            int index = UnityEngine.Random.Range(0, pool.Count);
            result.Add(pool[index]);
            pool.RemoveAt(index);
        }
        
        return result;
    }
 
    private ModifierType SelectModifierTypeForStat(StatType statType)
    {
        // Некоторые статы лучше работают с определенными типами модификаторов
        // Например, для здоровья обычно используется плоский модификатор,
        // а для шанса крита - аддитивный
        
        switch (statType)
        {
            case StatType.Health:
            case StatType.Damage:
                return ModifierType.Flat;
                
            case StatType.CritChance:
            case StatType.ElementalResistance:
                return ModifierType.Additive;
                
            case StatType.AttackSpeed:
            case StatType.MovementSpeed:
                return ModifierType.Multiplicative;
                
            default:
                // Случайный выбор из доступных типов
                return _availableModifierTypes[UnityEngine.Random.Range(0, _availableModifierTypes.Count)];
        }
    }
 
    private string GetRarityPrefix(float rarity)
    {
        if (rarity < 0.2f) return "Обычный";
        if (rarity < 0.4f) return "Необычный";
        if (rarity < 0.6f) return "Редкий";
        if (rarity < 0.8f) return "Эпический";
        return "Легендарный";
    }
 
    private string GetItemBaseName(ItemType type)
    {
        // Базовые имена для различных типов предметов
        // В реальном проекте здесь могут быть словари или более сложная логика
        
        switch (type)
        {
            case ItemType.Weapon:
                string[] weaponNames = { "Меч", "Топор", "Молот", "Кинжал", "Посох" };
                return weaponNames[UnityEngine.Random.Range(0, weaponNames.Length)];
                
            case ItemType.Armor:
                string[] armorNames = { "Нагрудник", "Шлем", "Поножи", "Перчатки", "Сапоги" };
                return armorNames[UnityEngine.Random.Range(0, armorNames.Length)];
                
            case ItemType.Accessory:
                string[] accessoryNames = { "Амулет", "Кольцо", "Браслет", "Пояс", "Кулон" };
                return accessoryNames[UnityEngine.Random.Range(0, accessoryNames.Length)];
                
            default:
                return "Предмет";
        }
    }
 
    private string GetMagicalSuffix()
    {
        string[] suffixes = {
            "Мощи", "Возмездия", "Жизненной силы", "Быстроты",
            "Мудрости", "Проницательности", "Превосходства", "Ярости"
        };
        
        return "of " + suffixes[UnityEngine.Random.Range(0, suffixes.Length)];
    }
}

public class CachingStat : Stat
{
    private struct CacheEntry
    {
        public float Value;
        public int ComputationId;
    }
 
    private int _currentComputationId = 0;
    private Dictionary<string, CacheEntry> _computationCache = new();
 
    public float GetComputedValueForContext(string cacheKey, Func<float, float> contextComputation)
    {
        // Если есть валидный кэш для этого контекста — используем его
        if (_computationCache.TryGetValue(cacheKey, out var entry) && 
            entry.ComputationId == _currentComputationId)
            return entry.Value;
 
        // Иначе вычисляем и сохраняем
        float computedValue = contextComputation(Value);
        _computationCache[cacheKey] = new CacheEntry 
        { 
            Value = computedValue, 
            ComputationId = _currentComputationId 
        };
        
        return computedValue;
    }
 
    public override void InvalidateCache()
    {
        base.InvalidateCache();
        _currentComputationId++;
        // Не обязательно чистить словарь - записи с устаревшим ID будут перезаписаны
    }
}

// Серверная часть
public class ServerStatController : MonoBehaviour
{
    private Dictionary<int, Dictionary<StatType, Stat>> _playerStats = new();
 
    public float GetPlayerStatValue(int playerId, StatType statType)
    {
        if (_playerStats.TryGetValue(playerId, out var stats) && 
            stats.TryGetValue(statType, out var stat))
            return stat.Value;
        
        return 0;
    }
 
    public void ValidateClientModifier(int playerId, StatType statType, 
                                      Modifier modifier, Action<bool> callback)
    {
        // Проверка на читерство или другие недопустимые модификаторы
        bool isValid = ValidateModifier(playerId, statType, modifier);
        
        if (isValid)
        {
            _playerStats[playerId][statType].AddModifier(modifier);
            // Отправка обновления всем клиентам...
        }
        
        callback(isValid);
    }
 
    private bool ValidateModifier(int playerId, StatType statType, Modifier modifier)
    {
        // Логика проверки легитимности модификатора
        return true; // Упрощённый пример
    }
}

[Serializable]
public struct StatDelta
{
    public int EntityId;
    public StatType Type;
    public float NewBaseValue;
    public List<ModifierDelta> ModifierChanges;
}
 
[Serializable]
public struct ModifierDelta
{
    public ModifierDeltaType ChangeType; // Добавлен, удалён, изменён
    public ModifierType Type;
    public float Value;
    public string SourceId;
}
 
// Применение дельты на клиенте
public void ApplyStatDelta(StatDelta delta)
{
    var entity = EntityManager.GetEntity(delta.EntityId);
    if (entity == null) return;
    
    var statComponent = entity.GetComponent<StatComponent>();
    var stat = statComponent.GetStat(delta.Type);
    
    // Обновление базового значения если изменилось
    if (Math.Abs(stat.BaseValue - delta.NewBaseValue) > float.Epsilon)
        stat.BaseValue = delta.NewBaseValue;
    
    // Применение изменений модификаторов
    foreach (var modDelta in delta.ModifierChanges)
    {
        switch (modDelta.ChangeType)
        {
            case ModifierDeltaType.Added:
                object source = null;
                if (!string.IsNullOrEmpty(modDelta.SourceId))
                    source = SourceRegistry.GetSource(modDelta.SourceId);
                
                stat.AddModifier(new Modifier(modDelta.Value, modDelta.Type, source));
                break;
                
            case ModifierDeltaType.Removed:
                // Удаление по значению и типу - упрощённо
                foreach (var mod in stat.GetModifiers(modDelta.Type))
                {
                    if (Math.Abs((float)mod - modDelta.Value) < float.Epsilon)
                    {
                        stat.TryRemoveModifier(mod);
                        break;
                    }
                }
                break;
        }
    }
}

public class GameSystems : MonoBehaviour
{
    [SerializeField] private StatSystem statSystem;
    [SerializeField] private InventorySystem inventorySystem;
    [SerializeField] private CombatSystem combatSystem;
    [SerializeField] private QuestSystem questSystem;
 
    private void Start()
    {
        // Подписка систем на события друг друга
        inventorySystem.ItemEquipped += OnItemEquipped;
        inventorySystem.ItemUnequipped += OnItemUnequipped;
        
        combatSystem.DamageDealt += OnDamageDealt;
        
        statSystem.StatThresholdCrossed += OnStatThresholdCrossed;
    }
 
    private void OnItemEquipped(Item item, Character character)
    {
        // Применение модификаторов предмета к статам персонажа
        statSystem.ApplyItemModifiers(item, character);
        
        // Проверка условий квестов
        questSystem.CheckItemEquipQuests(item, character);
    }
 
    private void OnItemUnequipped(Item item, Character character)
    {
        // Удаление модификаторов предмета из статов персонажа
        statSystem.RemoveItemModifiers(item, character);
    }
 
    private void OnDamageDealt(Character attacker, Character target, float amount)
    {
        // Обновление статистики боя
        statSystem.UpdateCombatStats(attacker, target, amount);
        
        // Проверка условий квестов
        questSystem.CheckCombatQuests(attacker, target, amount);
    }
 
    private void OnStatThresholdCrossed(Character character, StatType type, 
                                       float oldValue, float newValue, float threshold)
    {
        if (type == StatType.Health && newValue <= 0)
        {
            // Обработка смерти персонажа
            combatSystem.HandleCharacterDeath(character);
        }
        
        // Проверка условий квестов
        questSystem.CheckStatThresholdQuests(character, type, newValue, threshold);
    }
}

public static class StatEvents
{
    public static event Action<int, StatType, float> StatValueChanged;
    public static event Action<int, StatType, Modifier> ModifierAdded;
    public static event Action<int, StatType, Modifier> ModifierRemoved;
    
    public static void RaiseStatValueChanged(int entityId, StatType type, float newValue)
    {
        StatValueChanged?.Invoke(entityId, type, newValue);
    }
    
    // Другие методы вызова событий...
}

public class OptimizedStat : Stat
{
    private bool _flatModifiersChanged;
    private bool _additiveModifiersChanged;
    private bool _multiplicativeModifiersChanged;
    
    // Кэшированные промежуточные результаты
    private float _flatModifiersSum;
    private float _additiveEffect;
    
    protected override float CalculateModifiedValue()
    {
        if (_flatModifiersChanged)
        {
            _flatModifiersSum = CalculateFlatModifiersSum();
            _flatModifiersChanged = false;
        }
        
        if (_additiveModifiersChanged)
        {
            _additiveEffect = CalculateAdditiveEffect();
            _additiveModifiersChanged = false;
        }
        
        // И так далее...
        
        return BaseValue + _flatModifiersSum + _additiveEffect + CalculateMultiplicativeEffect();
    }
}

public class StatPerformanceMetrics : MonoBehaviour
{
    [SerializeField] private StatController statController;
    [SerializeField] private int iterationCount = 1000;
    
    [Button] // Используя расширение для Editor
    public void MeasureAddModifierPerformance()
    {
        var stat = statController.GetStat(StatType.Strength);
        var sw = Stopwatch.StartNew();
        
        for (int i = 0; i < iterationCount; i++)
        {
            var modifier = new Modifier(1, ModifierType.Flat);
            stat.AddModifier(modifier);
            stat.TryRemoveModifier(modifier);
        }
        
        sw.Stop();
        Debug.Log($"Модификаторы: {iterationCount} итераций за {sw.ElapsedMilliseconds}мс");
    }
}

[Test]
public void StatValueIsCorrectlyCalculatedWithMultipleModifiers()
{
    // Arrange
    var stat = new Stat(100);
    stat.AddModifier(new Modifier(10, ModifierType.Flat));
    stat.AddModifier(new Modifier(0.2f, ModifierType.Additive));
    stat.AddModifier(new Modifier(0.1f, ModifierType.Multiplicative));
    
    // Act
    float value = stat.Value;
    
    // Assert
    Assert.AreEqual(143, value, 0.01f);
    // Ожидаемое значение: 100 (база) + 10 (плоский) + 0.2*100 (аддитивный) = 130
    // Затем 130 + 130*0.1 (мультипликативный) = 143
}

[UnityTest]
public IEnumerator EquippingItemCorrectlyAffectsCharacterStats()
{
    // Arrange
    var character = GameObject.Instantiate(characterPrefab);
    var inventory = character.GetComponent<InventorySystem>();
    var statController = character.GetComponent<StatController>();
    
    var weapon = CreateTestWeapon(15, 0.1f);
    var initialStrength = statController.GetStat(StatType.Strength).Value;
    
    // Act
    inventory.EquipItem(weapon);
    yield return null; // Ждем кадр для обработки событий
    
    // Assert
    var newStrength = statController.GetStat(StatType.Strength).Value;
    Assert.AreEqual(initialStrength + 15, newStrength);
}

public class DebuggableStat : Stat
{
    [SerializeField] private bool enableDetailedLogging;
    
    public override void AddModifier(Modifier modifier)
    {
        base.AddModifier(modifier);
        
        if (enableDetailedLogging)
            Debug.Log($"[STAT] {Name} модификатор добавлен: {modifier}, новое значение: {Value}");
    }
    
    public void PrintModifiersBreakdown()
    {
        var sb = new StringBuilder();
        sb.AppendLine($"===== Информация о стате {Name} =====");
        sb.AppendLine($"Базовое значение: {BaseValue}");
        
        // Вывод детальной информации по категориям модификаторов
        // ...
        
        sb.AppendLine($"Итоговое значение: {Value}");
        Debug.Log(sb.ToString());
    }
}