Адаптивная случайность в Unity: динамические вероятности для улучшения игрового дизайна

public class AdaptiveProbabilityManager
{
    private static AdaptiveProbabilityManager _instance;
    public static AdaptiveProbabilityManager Instance => _instance ??= new AdaptiveProbabilityManager();
 
    // Хранилище счётчиков неудач для разных типов событий
    private Dictionary<string, int> _failureStreaks = new Dictionary<string, int>();
    
    // Настройки адаптации
    private const float BASE_INCREASE_PER_FAILURE = 0.05f; // 5% за каждую неудачу
    private const float MAX_MULTIPLIER = 3.0f; // Максимум втрое от базовой вероятности
 
    public float GetAdjustedProbability(string eventType, float baseProbability)
    {
        if (!_failureStreaks.ContainsKey(eventType))
            _failureStreaks[eventType] = 0;
 
        int failures = _failureStreaks[eventType];
        float increase = baseProbability * BASE_INCREASE_PER_FAILURE * failures;
        float adjusted = Mathf.Min(baseProbability + increase, baseProbability * MAX_MULTIPLIER);
        
        return Mathf.Clamp01(adjusted); // Ограничиваем диапазоном [0, 1]
    }
 
    public void RegisterResult(string eventType, bool success)
    {
        if (success)
        {
            _failureStreaks[eventType] = 0; // Сброс при успехе
        }
        else
        {
            if (!_failureStreaks.ContainsKey(eventType))
                _failureStreaks[eventType] = 0;
            
            _failureStreaks[eventType]++;
        }
    }
}

public class LootDropper : MonoBehaviour
{
    [SerializeField] private float _baseLegendaryChance = 0.05f; // 5% базовый шанс
 
    public void TryDropLegendary()
    {
        float adjustedChance = AdaptiveProbabilityManager.Instance
            .GetAdjustedProbability("legendary_drop", _baseLegendaryChance);
        
        bool dropped = Random.value <= adjustedChance;
        
        if (dropped)
        {
            // Создаём легендарный предмет
            SpawnLegendaryItem();
        }
        
        // Регистрируем результат для корректировки будущих попыток
        AdaptiveProbabilityManager.Instance.RegisterResult("legendary_drop", dropped);
    }
}

[CreateAssetMenu(fileName = "AdaptiveSettings", menuName = "Game/Adaptive Settings")]
public class AdaptiveSettings : ScriptableObject
{
    [Range(0f, 0.2f)]
    public float increasePerFailure = 0.05f; // Прирост за неудачу
    
    [Range(1.5f, 5f)]
    public float maxMultiplier = 3.0f; // Максимальный множитель
    
    [Range(0, 10)]
    public int minFailuresBeforeAdaptation = 2; // Порог активации
}

public enum AdaptiveEventType
{
    LegendaryDrop,
    CriticalHit,
    RareResource,
    BossLoot
}
 
public class AdaptiveProbabilityManager
{
    private Dictionary<AdaptiveEventType, int> _failureStreaks;
    private Dictionary<AdaptiveEventType, AdaptiveSettings> _settings;
    
    public void ConfigureEvent(AdaptiveEventType eventType, AdaptiveSettings settings)
    {
        _settings[eventType] = settings;
    }
    
    public float GetAdjustedProbability(AdaptiveEventType eventType, float baseProbability)
    {
        if (!_settings.ContainsKey(eventType))
        {
            // Запасной вариант, если настройки не заданы
            return baseProbability;
        }
        
        int failures = _failureStreaks.GetValueOrDefault(eventType, 0);
        var config = _settings[eventType];
        
        // Адаптация активируется только после порога
        if (failures < config.minFailuresBeforeAdaptation)
            return baseProbability;
        
        float increase = baseProbability * config.increasePerFailure * 
                        (failures - config.minFailuresBeforeAdaptation);
        float adjusted = Mathf.Min(baseProbability + increase, 
                                   baseProbability * config.maxMultiplier);
        
        return Mathf.Clamp01(adjusted);
    }
}

public struct EventRecord
{
    public AdaptiveEventType Type;
    public float Timestamp; // Time.time в момент события
    public float BaseProbability;
    public bool Success;
    
    // Опционально - контекст для продвинутого анализа
    public int PlayerLevel;
    public string Location;
}

private EventRecord[] _history;
private int _currentIndex;
private const int HISTORY_SIZE = 100;
 
public void RecordEvent(AdaptiveEventType type, float baseProbability, bool success)
{
    _history[_currentIndex] = new EventRecord
    {
        Type = type,
        Timestamp = Time.time,
        BaseProbability = baseProbability,
        Success = success
    };
    
    _currentIndex = (_currentIndex + 1) % HISTORY_SIZE; // Переход по кругу
}

public float CalculateProgressiveModifier(float baseProbability, int failures, float coefficient)
{
    // Используем степень 1.5 для плавного, но заметного ускорения
    float modifier = baseProbability * coefficient * Mathf.Pow(failures, 1.5f);
    return Mathf.Min(modifier, baseProbability * 3f); // Ограничиваем утроением
}

public float CalculateCombinedModifier(float baseProbability, int failures)
{
    const float LINEAR_COEF = 0.04f;
    const float LOG_COEF = 0.08f;
    
    float linearPart = LINEAR_COEF * failures;
    float logPart = LOG_COEF * Mathf.Log(failures + 1);
    
    return baseProbability * (1f + linearPart + logPart);
}

[System.Serializable]
public class AdaptiveSaveData
{
    // JsonUtility не умеет словари, используем параллельные массивы
    public string[] eventTypes;
    public int[] failureStreaks;
    public float saveTime;
    
    public AdaptiveSaveData(Dictionary<AdaptiveEventType, int> streaks)
    {
        int count = streaks.Count;
        eventTypes = new string[count];
        failureStreaks = new int[count];
        
        int index = 0;
        foreach (var pair in streaks)
        {
            eventTypes[index] = pair.Key.ToString();
            failureStreaks[index] = pair.Value;
            index++;
        }
        
        saveTime = Time.realtimeSinceStartup;
    }
}

public void SaveToPlayerPrefs()
{
    foreach (var pair in _failureStreaks)
    {
        string key = $"adaptive_streak_{pair.Key}";
        PlayerPrefs.SetInt(key, pair.Value);
    }
    
    PlayerPrefs.SetFloat("adaptive_save_time", Time.realtimeSinceStartup);
    PlayerPrefs.Save(); // Явный flush на диск
}
 
public void LoadFromPlayerPrefs()
{
    foreach (AdaptiveEventType type in System.Enum.GetValues(typeof(AdaptiveEventType)))
    {
        string key = $"adaptive_streak_{type}";
        if (PlayerPrefs.HasKey(key))
        {
            _failureStreaks[type] = PlayerPrefs.GetInt(key);
        }
    }
}

public class AdaptiveProbabilityManager
{
[System.Serializable]
public class ProbabilityEvent : UnityEvent<AdaptiveEventType, float> { }
 
public ProbabilityEvent OnProbabilityChanged = new ProbabilityEvent();
public UnityEvent<AdaptiveEventType> OnStreakBroken = new UnityEvent<AdaptiveEventType>();
 
public float GetAdjustedProbability(AdaptiveEventType eventType, float baseProbability)
{
    // ... расчёт вероятности ...
    
    // Оповещаем подписчиков об изменении
    OnProbabilityChanged?.Invoke(eventType, adjustedProbability);
    
    return adjustedProbability;
}
}

public class AdaptiveProbabilityManager
{
// Событие с двумя параметрами: тип события и новая вероятность
public event Action<AdaptiveEventType, float> ProbabilityAdjusted;
 
// Событие при успешном выпадении после серии неудач
public event Action<AdaptiveEventType, int> StreakEnded;
 
private void NotifyProbabilityChange(AdaptiveEventType type, float probability)
{
    ProbabilityAdjusted?.Invoke(type, probability);
}
}
 
// Использование в другом классе
public class LootUI : MonoBehaviour
{
private void OnEnable()
{
    AdaptiveProbabilityManager.Instance.ProbabilityAdjusted += UpdateLuckMeter;
}
 
private void OnDisable()
{
    AdaptiveProbabilityManager.Instance.ProbabilityAdjusted -= UpdateLuckMeter;
}
 
private void UpdateLuckMeter(AdaptiveEventType type, float probability)
{
    // Обновляем визуальный индикатор "удачи"
    if (type == AdaptiveEventType.LegendaryDrop)
        _luckSlider.value = probability;
}
}

public class TimeBasedAdaptiveManager
{
    private Queue<float> _eventTimestamps = new Queue<float>();
    private const float WINDOW_SECONDS = 60f; // Окно в 60 секунд
 
    public float GetRecentFailureRate()
    {
        float currentTime = Time.time;
        
        // Удаляем устаревшие события
        while (_eventTimestamps.Count > 0 && 
               currentTime - _eventTimestamps.Peek() > WINDOW_SECONDS)
        {
            _eventTimestamps.Dequeue();
        }
        
        // Возвращаем количество неудач за окно
        return _eventTimestamps.Count;
    }
 
    public void RecordFailure()
    {
        _eventTimestamps.Enqueue(Time.time);
    }
}

private float _emaFailureRate = 0f;
private const float EMA_ALPHA = 0.2f;
 
public void UpdateEMA(bool success)
{
    float outcome = success ? 0f : 1f; // Неудача = 1, успех = 0
    _emaFailureRate = EMA_ALPHA * outcome + (1f - EMA_ALPHA) * _emaFailureRate;
}
 
public float GetAdjustedProbability(float baseProbability)
{
    // Чем выше EMA (больше недавних неудач), тем сильнее коррекция
    float modifier = _emaFailureRate * 0.5f;
    return Mathf.Clamp01(baseProbability * (1f + modifier));
}

public class MultifactorAdaptiveManager
{
    // Весовые коэффициенты для каждого фактора
    private const float FAILURE_WEIGHT = 0.4f;
    private const float PLAYER_LEVEL_WEIGHT = 0.15f;
    private const float SESSION_TIME_WEIGHT = 0.2f;
    private const float DIFFICULTY_WEIGHT = 0.25f;
    
    public float CalculateAdaptiveModifier(
        int failureStreak, 
        int playerLevel, 
        float sessionMinutes,
        float locationDifficulty)
    {
        // Нормализуем каждый фактор в диапазон [0, 1]
        float failureFactor = Mathf.Clamp01(failureStreak / 10f);
        float levelFactor = 1f - Mathf.Clamp01(playerLevel / 100f); // Инверсия: новички получают бонус
        float timeFactor = Mathf.Clamp01(sessionMinutes / 120f); // До 2 часов учитываем
        float difficultyFactor = Mathf.Clamp01(locationDifficulty);
        
        // Взвешенная сумма всех факторов
        float totalModifier = 
            failureFactor * FAILURE_WEIGHT +
            levelFactor * PLAYER_LEVEL_WEIGHT +
            timeFactor * SESSION_TIME_WEIGHT +
            difficultyFactor * DIFFICULTY_WEIGHT;
        
        return totalModifier; // Результат в интервале [0, 1]
    }
}

private const float DECAY_LAMBDA = 0.05f; // Полураспад примерно за 14 часов
 
public float CalculateDecayedWeight(float eventTimestamp)
{
    float deltaTime = Time.time - eventTimestamp;
    float weight = Mathf.Exp(-DECAY_LAMBDA * deltaTime);
    return weight; // Значение от 1.0 (свежее) до ~0 (древнее)
}
 
public float GetWeightedFailureCount()
{
    float weightedSum = 0f;
    
    foreach (var record in _eventHistory)
    {
        if (!record.Success)
        {
            float weight = CalculateDecayedWeight(record.Timestamp);
            weightedSum += weight;
        }
    }
    
    return weightedSum;
}

public float CalculatePiecewiseWeight(float eventAge)
{
    const float FULL_WEIGHT_MINUTES = 10f;
    const float DECAY_MINUTES = 20f;
    
    if (eventAge < FULL_WEIGHT_MINUTES)
        return 1f;
    
    if (eventAge > FULL_WEIGHT_MINUTES + DECAY_MINUTES)
        return 0f;
    
    // Линейное падение в интервале
    float decayProgress = (eventAge - FULL_WEIGHT_MINUTES) / DECAY_MINUTES;
    return 1f - decayProgress;
}

public float GetHybridProbability(float baseProbability, int failureCount)
{
    float modifier;
    
    // Короткие серии: линейная, мягкая
    if (failureCount <= 5)
    {
        modifier = baseProbability * 0.02f * failureCount;
    }
    // Средние серии: прогрессивная
    else if (failureCount <= 15)
    {
        float adjusted = failureCount - 5;
        modifier = baseProbability * (0.1f + 0.05f * Mathf.Pow(adjusted, 1.3f));
    }
    // Экстремальные: экспоненциальная
    else
    {
        float excess = failureCount - 15;
        modifier = baseProbability * (1f + Mathf.Pow(1.2f, excess));
    }
    
    return Mathf.Clamp01(baseProbability + modifier);
}

public float GetSafeProbability(float baseProbability, int failureCount)
{
    // Защита от отрицательных счётчиков
    if (failureCount < 0)
    {
        Debug.LogWarning($"Отрицательный счётчик неудач: {failureCount}. Сброс в ноль.");
        failureCount = 0;
    }
    
    // Защита от нулевой базовой вероятности
    if (baseProbability <= 0f)
    {
        Debug.LogWarning($"Нулевая базовая вероятность для '{failureCount}' неудач");
        return 0f; // Адаптация бесполезна
    }
    
    // Ограничение счётчика для предотвращения переполнений
    failureCount = Mathf.Min(failureCount, 1000);
    
    float modifier = baseProbability * 0.05f * failureCount;
    float adjusted = baseProbability + modifier;
    
    // Финальная проверка на валидность
    if (float.IsNaN(adjusted) || float.IsInfinity(adjusted))
    {
        Debug.LogError("Получен невалидный результат расчёта вероятности!");
        return baseProbability;
    }
    
    return Mathf.Clamp01(adjusted);
}

public class LootBoxManager
{
    private const float BASE_LEGENDARY_CHANCE = 0.05f;
    private const float PITY_INCREMENT = 0.005f;
    private const int GUARANTEED_AT = 90; // Жёсткая гарантия
 
    public Item OpenLootBox()
    {
        int streak = AdaptiveProbabilityManager.Instance
            .GetFailureStreak("legendary_loot");
        
        // Гарантия на 90-й попытке без легенды
        if (streak >= GUARANTEED_AT)
        {
            AdaptiveProbabilityManager.Instance
                .RegisterResult("legendary_loot", true);
            return GenerateLegendaryItem();
        }
        
        float adjustedChance = BASE_LEGENDARY_CHANCE + 
                              (streak * PITY_INCREMENT);
        adjustedChance = Mathf.Clamp01(adjustedChance);
        
        bool isLegendary = Random.value <= adjustedChance;
        AdaptiveProbabilityManager.Instance
            .RegisterResult("legendary_loot", isLegendary);
        
        return isLegendary ? GenerateLegendaryItem() : GenerateCommonItem();
    }
}

public class CombatCritSystem
{
private const float PLAYER_BASE_CRIT = 0.2f;
private const float ENEMY_BASE_CRIT = 0.15f;
 
public bool CheckPlayerCrit(string playerId)
{
    int noLuckStreak = AdaptiveProbabilityManager.Instance
        .GetFailureStreak($"player_crit_{playerId}");
    
    // Мягкое увеличение - по 3% за каждый промах
    float bonus = noLuckStreak * 0.03f;
    float chance = Mathf.Min(PLAYER_BASE_CRIT + bonus, 0.5f); // Максимум 50%
    
    bool isCrit = Random.value <= chance;
    AdaptiveProbabilityManager.Instance
        .RegisterResult($"player_crit_{playerId}", isCrit);
    
    return isCrit;
}
 
public bool CheckEnemyCrit(Enemy enemy, float playerHealthPercent)
{
    int critStreak = AdaptiveProbabilityManager.Instance
        .GetSuccessStreak($"enemy_crit_{enemy.Id}"); // Считаем успехи, не неудачи!
    
    // Снижаем шанс после критов
    float penalty = critStreak * 0.05f;
    float chance = Mathf.Max(ENEMY_BASE_CRIT - penalty, 0.05f); // Минимум 5%
    
    // Дополнительное снижение при низком здоровье игрока
    if (playerHealthPercent < 0.3f)
        chance *= 0.7f; // -30% к шансу крита
    
    bool isCrit = Random.value <= chance;
    AdaptiveProbabilityManager.Instance
        .RegisterResult($"enemy_crit_{enemy.Id}", isCrit);
    
    return isCrit;
}
}

public class AdaptiveRoomGenerator
{
    private const float BASE_ENEMY_CHANCE = 0.4f;
    private const float BASE_TRAP_CHANCE = 0.3f;
    private const float BASE_TREASURE_CHANCE = 0.2f;
    
    public RoomType GenerateNext()
    {
        int emptyStreak = AdaptiveProbabilityManager.Instance
            .GetFailureStreak("content_room");
        
        // После трёх пустых комнат резко повышаем шанс контента
        float contentBonus = emptyStreak >= 3 ? 0.3f : 0f;
        
        float enemyChance = BASE_ENEMY_CHANCE + contentBonus;
        float trapChance = BASE_TRAP_CHANCE + contentBonus * 0.5f;
        float treasureChance = BASE_TREASURE_CHANCE + contentBonus * 0.7f;
        
        float roll = Random.value;
        
        if (roll < enemyChance)
        {
            AdaptiveProbabilityManager.Instance
                .RegisterResult("content_room", true);
            return RoomType.Enemy;
        }
        
        if (roll < enemyChance + trapChance)
        {
            AdaptiveProbabilityManager.Instance
                .RegisterResult("content_room", true);
            return RoomType.Trap;
        }
        
        if (roll < enemyChance + trapChance + treasureChance)
        {
            AdaptiveProbabilityManager.Instance
                .RegisterResult("content_room", true);
            return RoomType.Treasure;
        }
        
        // Пустая комната считается "неудачей" для адаптации
        AdaptiveProbabilityManager.Instance
            .RegisterResult("content_room", false);
        return RoomType.Empty;
    }
}

public class ProgressionRewardSystem
{
    private Dictionary<RewardType, int> _receivedRewards = new();
    
    public RewardType SelectLevelUpReward(List<RewardType> availableRewards)
    {
        // Вычисляем веса с учётом истории получения
        Dictionary<RewardType, float> weights = new();
        
        foreach (var reward in availableRewards)
        {
            int timesReceived = _receivedRewards.GetValueOrDefault(reward, 0);
            
            // Базовый вес 1.0, снижается экспоненциально с каждым получением
            float weight = Mathf.Pow(0.4f, timesReceived);
            weights[reward] = Mathf.Max(weight, 0.05f); // Минимум 5%, чтобы не обнулять
        }
        
        // Weighted random с адаптивными весами
        float totalWeight = weights.Values.Sum();
        float roll = Random.value * totalWeight;
        float accumulated = 0f;
        
        foreach (var pair in weights)
        {
            accumulated += pair.Value;
            if (roll <= accumulated)
            {
                _receivedRewards[pair.Key] = _receivedRewards.GetValueOrDefault(pair.Key, 0) + 1;
                return pair.Key;
            }
        }
        
        return availableRewards[0]; // Запасной вариант
    }
}

public class AdaptiveEnemyAI
{
    private const float BASE_ACCURACY = 0.7f;
    
    public bool TryHitPlayer(float playerHealthPercent, int playerWinStreak)
    {
        // Снижаем точность при низком здоровье игрока
        float healthModifier = playerHealthPercent < 0.3f ? -0.2f : 0f;
        
        // Повышаем после серии побед игрока
        float streakModifier = playerWinStreak * 0.05f;
        streakModifier = Mathf.Clamp(streakModifier, -0.15f, 0.2f);
        
        float adjustedAccuracy = BASE_ACCURACY + healthModifier + streakModifier;
        adjustedAccuracy = Mathf.Clamp(adjustedAccuracy, 0.3f, 0.9f); // Диапазон 30-90%
        
        return Random.value <= adjustedAccuracy;
    }
    
    public float GetAbilityCooldown(float combatDuration)
    {
        const float BASE_COOLDOWN = 15f;
        
        // Ускоряем способности в затянувшихся боях
        if (combatDuration > 180f)
            return BASE_COOLDOWN * 0.6f; // -40% время восстановления
        
        if (combatDuration > 120f)
            return BASE_COOLDOWN * 0.8f;
        
        return BASE_COOLDOWN;
    }
}

public class AdaptiveWaveSpawner
{
    private Dictionary<EnemyType, int> _lastWavesCounts = new();
    private const int WAVE_MEMORY = 3;
    
    public List<Enemy> GenerateWave(int waveNumber)
    {
        float budget = waveNumber * 10f; // Общая "стоимость" врагов растёт
        List<Enemy> wave = new();
        
        while (budget > 0)
        {
            EnemyType type = SelectEnemyType();
            wave.Add(CreateEnemy(type));
            budget -= GetEnemyCost(type);
            
            _lastWavesCounts[type] = _lastWavesCounts.GetValueOrDefault(type, 0) + 1;
        }
        
        return wave;
    }
    
    private EnemyType SelectEnemyType()
    {
        // Снижаем вес типов, которые часто появлялись
        Dictionary<EnemyType, float> weights = new();
        
        foreach (EnemyType type in System.Enum.GetValues(typeof(EnemyType)))
        {
            int recentCount = _lastWavesCounts.GetValueOrDefault(type, 0);
            float weight = 1f / (1f + recentCount * 0.3f); // Чем больше было, тем меньше вес
            weights[type] = weight;
        }
        
        return WeightedRandom(weights);
    }
}

// Кеш для частых запросов
private Dictionary<string, float> _probabilityCache = new();
private int _cacheHits = 0;
private int _cacheMisses = 0;
 
public float GetCachedProbability(string eventType, float baseProbability)
{
    string cacheKey = $"{eventType}_{Time.frameCount}";
    
    if (_probabilityCache.TryGetValue(cacheKey, out float cached))
    {
        _cacheHits++;
        return cached;
    }
    
    _cacheMisses++;
    float result = CalculateProbability(eventType, baseProbability);
    
    // Кеш на один кадр, потом сбрасываем
    _probabilityCache[cacheKey] = result;
    return result;
}

[CreateAssetMenu(fileName = "AdaptiveConfig", menuName = "Loot/Adaptive Configuration")]
public class AdaptiveConfiguration : ScriptableObject
{
    [Header("Базовые вероятности")]
    [Range(0f, 1f)]
    [Tooltip("Шанс получить обычный предмет")]
    public float commonDropChance = 0.6f;
    
    [Range(0f, 1f)]
    public float rareDropChance = 0.3f;
    
    [Range(0f, 1f)]
    public float legendaryDropChance = 0.1f;
    
    [Header("Параметры адаптации")]
    [Range(0f, 0.2f)]
    [Tooltip("Прирост вероятности за каждую неудачу")]
    public float incrementPerFailure = 0.05f;
    
    [Range(1f, 5f)]
    [Tooltip("Максимальный множитель роста вероятности")]
    public float maxProbabilityMultiplier = 2.5f;
    
    [Range(0, 20)]
    [Tooltip("Количество неудач до активации адаптации")]
    public int adaptationThreshold = 3;
    
    [Header("Жёсткие гарантии")]
    [Range(10, 200)]
    [Tooltip("Гарантированный дроп после N неудач")]
    public int guaranteedDropAt = 50;
    
    [Header("Временные параметры")]
    [Range(0f, 1f)]
    [Tooltip("Скорость затухания влияния старых событий")]
    public float timeDecayRate = 0.1f;
}

private void OnValidate()
{
    // Проверяем, что сумма базовых вероятностей не превышает 100%
    float total = commonDropChance + rareDropChance + legendaryDropChance;
    if (total > 1f)
    {
        Debug.LogWarning($"Сумма вероятностей {total:F2} превышает 100%! Нормализуем значения.");
        float scale = 1f / total;
        commonDropChance *= scale;
        rareDropChance *= scale;
        legendaryDropChance *= scale;
    }
    
    // Гарантия должна срабатывать после порога адаптации
    if (guaranteedDropAt <= adaptationThreshold)
    {
        guaranteedDropAt = adaptationThreshold + 10;
        Debug.LogWarning("Гарантия скорректирована - должна быть больше порога адаптации");
    }
}

public class LootDebugVisualizer : MonoBehaviour
{
    [SerializeField] private LineRenderer _probabilityGraph;
    [SerializeField] private Text _statsDisplay;
    
    private List<float> _recentProbabilities = new(100);
    
    public void UpdateVisualization(float currentProbability, int streak)
    {
        // Отслеживаем историю вероятностей
        _recentProbabilities.Add(currentProbability);
        if (_recentProbabilities.Count > 100)
            _recentProbabilities.RemoveAt(0);
        
        // Рисуем график изменения вероятности
        _probabilityGraph.positionCount = _recentProbabilities.Count;
        for (int i = 0; i < _recentProbabilities.Count; i++)
        {
            float x = i * 0.1f;
            float y = _recentProbabilities[i] * 10f;
            _probabilityGraph.SetPosition(i, new Vector3(x, y, 0));
        }
        
        // Обновляем текстовую статистику
        _statsDisplay.text = $"Текущая вероятность: {currentProbability:P1}\n" +
                            $"Серия неудач: {streak}\n" +
                            $"Средняя вероятность: {_recentProbabilities.Average():P1}";
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
 
/// <summary>
/// Ядро системы адаптивных вероятностей. Управляет историей событий и расчётом модификаторов.
/// Не содержит Unity-зависимостей - можно использовать в любом .NET приложении.
/// </summary>
public class AdaptiveProbabilityCore
{
    // Запись о событии в истории
    public struct EventRecord
    {
        public string EventType;          // Идентификатор типа события
        public float Timestamp;            // Время события
        public float BaseProbability;      // Исходная вероятность
        public bool Success;               // Результат (успех/неудача)
        public int PlayerLevel;            // Контекст: уровень игрока
        
        public EventRecord(string type, float timestamp, float probability, bool success, int level = 0)
        {
            EventType = type;
            Timestamp = timestamp;
            BaseProbability = probability;
            Success = success;
            PlayerLevel = level;
        }
    }
    
    // Настройки для конкретного типа события
    public class EventSettings
    {
        public float IncrementPerFailure = 0.05f;     // Прирост за неудачу
        public float MaxMultiplier = 2.5f;            // Максимальный множитель
        public int ActivationThreshold = 3;           // Порог активации
        public int GuaranteedAt = 50;                 // Жёсткая гарантия
        public bool UseProgressiveScaling = false;    // Использовать прогрессивную формулу
        public float ProgressiveExponent = 1.5f;      // Степень для прогрессии
    }
    
    // Счётчики неудач для каждого типа события
    private Dictionary<string, int> _failureStreaks = new Dictionary<string, int>();
    
    // История событий (кольцевой буфер)
    private EventRecord[] _history;
    private int _currentIndex = 0;
    private const int HISTORY_SIZE = 200;
    
    // Настройки для разных типов событий
    private Dictionary<string, EventSettings> _eventSettings = new Dictionary<string, EventSettings>();
    
    // Статистика для аналитики
    public int TotalEvents { get; private set; }
    public int TotalSuccesses { get; private set; }
    public int TotalFailures { get; private set; }
    
    // События для внешних подписчиков
    public event Action<string, float> OnProbabilityCalculated;
    public event Action<string, bool, int> OnEventRegistered;
    
    public AdaptiveProbabilityCore()
    {
        _history = new EventRecord[HISTORY_SIZE];
        
        // Настройки по умолчанию для разных типов событий
        ConfigureEvent("legendary_drop", new EventSettings 
        { 
            IncrementPerFailure = 0.01f,
            MaxMultiplier = 3.0f,
            ActivationThreshold = 2,
            GuaranteedAt = 90,
            UseProgressiveScaling = true,
            ProgressiveExponent = 1.5f
        });
        
        ConfigureEvent("rare_drop", new EventSettings 
        { 
            IncrementPerFailure = 0.03f,
            MaxMultiplier = 2.0f,
            ActivationThreshold = 2,
            GuaranteedAt = 30
        });
    }
    
    /// <summary>
    /// Настройка параметров адаптации для конкретного типа события
    /// </summary>
    public void ConfigureEvent(string eventType, EventSettings settings)
    {
        _eventSettings[eventType] = settings;
    }
    
    /// <summary>
    /// Получить скорректированную вероятность с учётом истории неудач
    /// </summary>
    public float GetAdjustedProbability(string eventType, float baseProbability, float currentTime, int playerLevel = 0)
    {
        // Защита от некорректных входных данных
        if (baseProbability <= 0f)
        {
            return 0f;
        }
        
        baseProbability = Math.Clamp(baseProbability, 0f, 1f);
        
        // Получаем настройки для этого типа события
        if (!_eventSettings.TryGetValue(eventType, out var settings))
        {
            // Если настройки не заданы, используем базовую вероятность
            OnProbabilityCalculated?.Invoke(eventType, baseProbability);
            return baseProbability;
        }
        
        // Получаем текущую серию неудач
        int failures = _failureStreaks.GetValueOrDefault(eventType, 0);
        
        // Проверяем жёсткую гарантию
        if (failures >= settings.GuaranteedAt)
        {
            OnProbabilityCalculated?.Invoke(eventType, 1.0f);
            return 1.0f; // Гарантированный успех
        }
        
        // Адаптация активируется только после порога
        if (failures < settings.ActivationThreshold)
        {
            OnProbabilityCalculated?.Invoke(eventType, baseProbability);
            return baseProbability;
        }
        
        // Вычисляем модификатор
        int effectiveFailures = failures - settings.ActivationThreshold;
        float modifier;
        
        if (settings.UseProgressiveScaling)
        {
            // Прогрессивная формула: P_adj = P_base + P_base * k * n^exp
            modifier = baseProbability * settings.IncrementPerFailure * 
                      (float)Math.Pow(effectiveFailures, settings.ProgressiveExponent);
        }
        else
        {
            // Линейная формула: P_adj = P_base + P_base * k * n
            modifier = baseProbability * settings.IncrementPerFailure * effectiveFailures;
        }
        
        // Применяем модификатор с учётом максимального предела
        float adjusted = baseProbability + modifier;
        adjusted = Math.Min(adjusted, baseProbability * settings.MaxMultiplier);
        adjusted = Math.Clamp(adjusted, 0f, 1f);
        
        // Финальная проверка на валидность
        if (float.IsNaN(adjusted) || float.IsInfinity(adjusted))
        {
            adjusted = baseProbability;
        }
        
        OnProbabilityCalculated?.Invoke(eventType, adjusted);
        return adjusted;
    }
    
    /// <summary>
    /// Регистрация результата события для обновления счётчиков
    /// </summary>
    public void RegisterEvent(string eventType, float baseProbability, bool success, float currentTime, int playerLevel = 0)
    {
        // Обновляем счётчики
        if (success)
        {
            _failureStreaks[eventType] = 0; // Сброс при успехе
            TotalSuccesses++;
        }
        else
        {
            _failureStreaks[eventType] = _failureStreaks.GetValueOrDefault(eventType, 0) + 1;
            TotalFailures++;
        }
        
        TotalEvents++;
        
        // Записываем в историю
        _history[_currentIndex] = new EventRecord(
            eventType, 
            currentTime, 
            baseProbability, 
            success, 
            playerLevel
        );
        
        _currentIndex = (_currentIndex + 1) % HISTORY_SIZE;
        
        // Оповещаем подписчиков
        int currentStreak = _failureStreaks.GetValueOrDefault(eventType, 0);
        OnEventRegistered?.Invoke(eventType, success, currentStreak);
    }
    
    /// <summary>
    /// Получить текущую серию неудач для типа события
    /// </summary>
    public int GetFailureStreak(string eventType)
    {
        return _failureStreaks.GetValueOrDefault(eventType, 0);
    }
    
    /// <summary>
    /// Получить историю событий за последние N записей
    /// </summary>
    public IEnumerable<EventRecord> GetRecentHistory(int count)
    {
        count = Math.Min(count, HISTORY_SIZE);
        var result = new List<EventRecord>(count);
        
        for (int i = 0; i < count; i++)
        {
            int index = (_currentIndex - 1 - i + HISTORY_SIZE) % HISTORY_SIZE;
            var record = _history[index];
            
            // Пропускаем пустые записи (в начале работы)
            if (record.Timestamp > 0)
            {
                result.Add(record);
            }
        }
        
        return result;
    }
    
    /// <summary>
    /// Получить всю историю событий
    /// </summary>
    public IEnumerable<EventRecord> GetFullHistory()
    {
        return _history.Where(r => r.Timestamp > 0);
    }
    
    /// <summary>
    /// Сброс всех счётчиков (для тестирования)
    /// </summary>
    public void Reset()
    {
        _failureStreaks.Clear();
        _history = new EventRecord[HISTORY_SIZE];
        _currentIndex = 0;
        TotalEvents = 0;
        TotalSuccesses = 0;
        TotalFailures = 0;
    }
    
    /// <summary>
    /// Получить статистику по типу события
    /// </summary>
    public (int total, int successes, int failures, float successRate) GetEventStatistics(string eventType)
    {
        var events = _history.Where(r => r.EventType == eventType && r.Timestamp > 0).ToList();
        int total = events.Count;
        int successes = events.Count(e => e.Success);
        int failures = total - successes;
        float successRate = total > 0 ? (float)successes / total : 0f;
        
        return (total, successes, failures, successRate);
    }
}

using UnityEngine;
 
/// <summary>
/// Конфигурация системы адаптивного лута.
/// Создайте несколько пресетов для разных режимов сложности.
/// </summary>
[CreateAssetMenu(fileName = "AdaptiveConfig", menuName = "AdaptiveLoot/Configuration")]
public class AdaptiveConfiguration : ScriptableObject
{
    [Header("Базовые вероятности дропа")]
    [Range(0f, 1f)]
    [Tooltip("Шанс получить обычный предмет")]
    public float commonDropChance = 0.6f;
    
    [Range(0f, 1f)]
    [Tooltip("Шанс получить редкий предмет")]
    public float rareDropChance = 0.3f;
    
    [Range(0f, 1f)]
    [Tooltip("Шанс получить легендарный предмет")]
    public float legendaryDropChance = 0.1f;
    
    [Header("Настройки адаптации для легендарок")]
    [Range(0f, 0.1f)]
    [Tooltip("Прирост вероятности легенды за каждую неудачу")]
    public float legendaryIncrement = 0.01f;
    
    [Range(1f, 5f)]
    [Tooltip("Максимальный множитель для легендарных дропов")]
    public float legendaryMaxMultiplier = 3.0f;
    
    [Range(0, 10)]
    [Tooltip("Минимум неудач перед началом адаптации легендарок")]
    public int legendaryThreshold = 2;
    
    [Range(10, 200)]
    [Tooltip("Гарантированная легенда после N неудач")]
    public int legendaryGuarantee = 90;
    
    [Header("Настройки адаптации для редких предметов")]
    [Range(0f, 0.2f)]
    public float rareIncrement = 0.03f;
    
    [Range(1f, 3f)]
    public float rareMaxMultiplier = 2.0f;
    
    [Range(0, 10)]
    public int rareThreshold = 2;
    
    [Range(5, 50)]
    public int rareGuarantee = 30;
    
    [Header("Дополнительные параметры")]
    [Tooltip("Использовать прогрессивную формулу вместо линейной")]
    public bool useProgressiveScaling = true;
    
    [Range(1.1f, 2f)]
    [Tooltip("Степень для прогрессивной формулы")]
    public float progressiveExponent = 1.5f;
    
    [Tooltip("Включить режим отладки с подробным логированием")]
    public bool debugMode = false;
    
    private void OnValidate()
    {
        // Проверка суммы вероятностей
        float total = commonDropChance + rareDropChance + legendaryDropChance;
        if (total > 1.01f) // Небольшой допуск на погрешность округления
        {
            Debug.LogWarning($"[AdaptiveConfig] Сумма вероятностей {total:F3} превышает 100%! Нормализуем.");
            float scale = 1f / total;
            commonDropChance *= scale;
            rareDropChance *= scale;
            legendaryDropChance *= scale;
        }
        
        // Проверка порогов гарантии
        if (legendaryGuarantee <= legendaryThreshold)
        {
            legendaryGuarantee = legendaryThreshold + 10;
            Debug.LogWarning("[AdaptiveConfig] Гарантия легенды скорректирована");
        }
        
        if (rareGuarantee <= rareThreshold)
        {
            rareGuarantee = rareThreshold + 5;
            Debug.LogWarning("[AdaptiveConfig] Гарантия редкого дропа скорректирована");
        }
    }
    
    /// <summary>
    /// Создать настройки ядра из этой конфигурации
    /// </summary>
    public AdaptiveProbabilityCore.EventSettings GetLegendarySettings()
    {
        return new AdaptiveProbabilityCore.EventSettings
        {
            IncrementPerFailure = legendaryIncrement,
            MaxMultiplier = legendaryMaxMultiplier,
            ActivationThreshold = legendaryThreshold,
            GuaranteedAt = legendaryGuarantee,
            UseProgressiveScaling = useProgressiveScaling,
            ProgressiveExponent = progressiveExponent
        };
    }
    
    public AdaptiveProbabilityCore.EventSettings GetRareSettings()
    {
        return new AdaptiveProbabilityCore.EventSettings
        {
            IncrementPerFailure = rareIncrement,
            MaxMultiplier = rareMaxMultiplier,
            ActivationThreshold = rareThreshold,
            GuaranteedAt = rareGuarantee,
            UseProgressiveScaling = useProgressiveScaling,
            ProgressiveExponent = progressiveExponent
        };
    }
}

using UnityEngine;
 
/// <summary>
/// Редкость предмета
/// </summary>
public enum ItemRarity
{
    Common,
    Rare,
    Legendary
}
 
/// <summary>
/// Предмет лута
/// </summary>
[System.Serializable]
public class LootItem
{
    public string Name;
    public ItemRarity Rarity;
    public Sprite Icon;
    public Color RarityColor;
    
    public LootItem(string name, ItemRarity rarity)
    {
        Name = name;
        Rarity = rarity;
        
        // Цвета по редкости
        RarityColor = rarity switch
        {
            ItemRarity.Common => new Color(0.7f, 0.7f, 0.7f),      // Серый
            ItemRarity.Rare => new Color(0.3f, 0.5f, 1f),          // Синий
            ItemRarity.Legendary => new Color(1f, 0.6f, 0f),       // Оранжевый
            _ => Color.white
        };
    }
}
 
/// <summary>
/// Результаты симуляции для аналитики
/// </summary>
public class SimulationResults
{
    public int TotalAttempts;
    public int CommonDrops;
    public int RareDrops;
    public int LegendaryDrops;
    
    public List<int> FailureStreakLengths = new List<int>();
    public float AverageStreakLength;
    public int MaxStreakLength;
    public float LegendaryDropRate;
    
    public void Calculate()
    {
        if (TotalAttempts > 0)
        {
            LegendaryDropRate = (float)LegendaryDrops / TotalAttempts;
        }
        
        if (FailureStreakLengths.Count > 0)
        {
            AverageStreakLength = (float)FailureStreakLengths.Sum() / FailureStreakLengths.Count;
            MaxStreakLength = FailureStreakLengths.Max();
        }
    }
}

using UnityEngine;
using System.Collections.Generic;
 
/// <summary>
/// Адаптер между ядром адаптивных вероятностей и игровой системой лута.
/// MonoBehaviour для интеграции с Unity.
/// </summary>
public class LootSystemAdapter : MonoBehaviour
{
    [Header("Конфигурация")]
    [SerializeField] private AdaptiveConfiguration _config;
    
    [Header("Префабы предметов")]
    [SerializeField] private GameObject _commonItemPrefab;
    [SerializeField] private GameObject _rareItemPrefab;
    [SerializeField] private GameObject _legendaryItemPrefab;
    
    [Header("Визуальные эффекты")]
    [SerializeField] private ParticleSystem _commonDropEffect;
    [SerializeField] private ParticleSystem _rareDropEffect;
    [SerializeField] private ParticleSystem _legendaryDropEffect;
    
    // Ядро системы
    private AdaptiveProbabilityCore _core;
    
    // Статистика текущей сессии
    public int SessionAttempts { get; private set; }
    public int SessionLegendaries { get; private set; }
    
    // События для UI
    public event System.Action<LootItem> OnItemDropped;
    public event System.Action<float, int> OnProbabilityUpdated;
    
    private void Awake()
    {
        InitializeCore();
    }
    
    private void InitializeCore()
    {
        _core = new AdaptiveProbabilityCore();
        
        // Применяем настройки из ScriptableObject
        _core.ConfigureEvent("legendary_drop", _config.GetLegendarySettings());
        _core.ConfigureEvent("rare_drop", _config.GetRareSettings());
        
        // Подписываемся на события ядра для логирования
        if (_config.debugMode)
        {
            _core.OnProbabilityCalculated += LogProbabilityCalculation;
            _core.OnEventRegistered += LogEventRegistration;
        }
    }
    
    /// <summary>
    /// Открыть сундук и получить предмет
    /// </summary>
    public LootItem OpenChest(int playerLevel = 1)
    {
        SessionAttempts++;
        float currentTime = Time.time;
        
        // Сначала проверяем легендарный дроп
        float legendaryChance = _core.GetAdjustedProbability(
            "legendary_drop", 
            _config.legendaryDropChance, 
            currentTime,
            playerLevel
        );
        
        bool isLegendary = Random.value <= legendaryChance;
        _core.RegisterEvent("legendary_drop", _config.legendaryDropChance, isLegendary, currentTime, playerLevel);
        
        if (isLegendary)
        {
            SessionLegendaries++;
            var item = new LootItem($"Легенда #{SessionLegendaries}", ItemRarity.Legendary);
            OnItemDropped?.Invoke(item);
            PlayDropEffect(ItemRarity.Legendary);
            
            // Обновляем UI
            int streak = _core.GetFailureStreak("legendary_drop");
            OnProbabilityUpdated?.Invoke(legendaryChance, streak);
            
            return item;
        }
        
        // Затем проверяем редкий дроп
        float rareChance = _core.GetAdjustedProbability(
            "rare_drop",
            _config.rareDropChance,
            currentTime,
            playerLevel
        );
        
        bool isRare = Random.value <= rareChance;
        _core.RegisterEvent("rare_drop", _config.rareDropChance, isRare, currentTime, playerLevel);
        
        if (isRare)
        {
            var item = new LootItem($"Редкий предмет", ItemRarity.Rare);
            OnItemDropped?.Invoke(item);
            PlayDropEffect(ItemRarity.Rare);
            return item;
        }
        
        // Иначе выдаём обычный предмет
        var commonItem = new LootItem($"Обычный предмет", ItemRarity.Common);
        OnItemDropped?.Invoke(commonItem);
        PlayDropEffect(ItemRarity.Common);
        
        // Обновляем UI для легендарок
        int legendaryStreak = _core.GetFailureStreak("legendary_drop");
        OnProbabilityUpdated?.Invoke(legendaryChance, legendaryStreak);
        
        return commonItem;
    }
    
    private void PlayDropEffect(ItemRarity rarity)
    {
        ParticleSystem effect = rarity switch
        {
            ItemRarity.Common => _commonDropEffect,
            ItemRarity.Rare => _rareDropEffect,
            ItemRarity.Legendary => _legendaryDropEffect,
            _ => null
        };
        
        if (effect != null)
        {
            effect.Play();
        }
    }
    
    /// <summary>
    /// Получить ядро для прямого доступа (для аналитики)
    /// </summary>
    public AdaptiveProbabilityCore GetCore() => _core;
    
    /// <summary>
    /// Сброс статистики
    /// </summary>
    public void ResetStats()
    {
        _core.Reset();
        SessionAttempts = 0;
        SessionLegendaries = 0;
    }
    
    private void LogProbabilityCalculation(string eventType, float probability)
    {
        Debug.Log($"[Adaptive] {eventType}: вероятность = {probability:P2}");
    }
    
    private void LogEventRegistration(string eventType, bool success, int streak)
    {
        string result = success ? "<color=green>УСПЕХ</color>" : "<color=yellow>НЕУДАЧА</color>";
        Debug.Log($"[Adaptive] {eventType}: {result}, серия неудач = {streak}");
    }
}

using UnityEngine;
using System.Collections.Generic;
using System.Linq;
 
/// <summary>
/// Аналитика системы адаптивного лута.
/// Собирает статистику, строит распределения, сравнивает с Random.
/// </summary>
public class LootAnalytics
{
    private AdaptiveProbabilityCore _core;
    
    // Кеш результатов симуляций
    private SimulationResults _lastAdaptiveResults;
    private SimulationResults _lastRandomResults;
    
    public LootAnalytics(AdaptiveProbabilityCore core)
    {
        _core = core;
    }
    
    /// <summary>
    /// Симуляция с адаптивной системой
    /// </summary>
    public SimulationResults SimulateAdaptive(
        int attempts, 
        float legendaryChance, 
        float rareChance,
        AdaptiveProbabilityCore.EventSettings legendarySettings)
    {
        var results = new SimulationResults { TotalAttempts = attempts };
        var tempCore = new AdaptiveProbabilityCore();
        tempCore.ConfigureEvent("legendary", legendarySettings);
        
        int currentStreak = 0;
        
        for (int i = 0; i < attempts; i++)
        {
            float time = i * 0.1f;
            
            // Проверяем легенду
            float adjustedLegendary = tempCore.GetAdjustedProbability("legendary", legendaryChance, time);
            bool gotLegendary = Random.value <= adjustedLegendary;
            tempCore.RegisterEvent("legendary", legendaryChance, gotLegendary, time);
            
            if (gotLegendary)
            {
                results.LegendaryDrops++;
                if (currentStreak > 0)
                {
                    results.FailureStreakLengths.Add(currentStreak);
                    currentStreak = 0;
                }
                continue;
            }
            
            // Проверяем редкий
            bool gotRare = Random.value <= rareChance;
            if (gotRare)
            {
                results.RareDrops++;
                currentStreak++;
                continue;
            }
            
            // Обычный
            results.CommonDrops++;
            currentStreak++;
        }
        
        // Записываем последнюю серию, если была
        if (currentStreak > 0)
        {
            results.FailureStreakLengths.Add(currentStreak);
        }
        
        results.Calculate();
        _lastAdaptiveResults = results;
        return results;
    }
    
    /// <summary>
    /// Симуляция с чистым Random для сравнения
    /// </summary>
    public SimulationResults SimulateRandom(int attempts, float legendaryChance, float rareChance)
    {
        var results = new SimulationResults { TotalAttempts = attempts };
        int currentStreak = 0;
        
        for (int i = 0; i < attempts; i++)
        {
            // Чистый Random без адаптации
            if (Random.value <= legendaryChance)
            {
                results.LegendaryDrops++;
                if (currentStreak > 0)
                {
                    results.FailureStreakLengths.Add(currentStreak);
                    currentStreak = 0;
                }
                continue;
            }
            
            if (Random.value <= rareChance)
            {
                results.RareDrops++;
                currentStreak++;
                continue;
            }
            
            results.CommonDrops++;
            currentStreak++;
        }
        
        if (currentStreak > 0)
        {
            results.FailureStreakLengths.Add(currentStreak);
        }
        
        results.Calculate();
        _lastRandomResults = results;
        return results;
    }
    
    /// <summary>
    /// Получить сравнительную статистику
    /// </summary>
    public string GetComparisonReport()
    {
        if (_lastAdaptiveResults == null || _lastRandomResults == null)
        {
            return "Запустите симуляции для получения отчёта";
        }
        
        var adaptive = _lastAdaptiveResults;
        var random = _lastRandomResults;
        
        return $"=== СРАВНЕНИЕ АДАПТИВНОЙ СИСТЕМЫ И RANDOM ===\n\n" +
               $"Легендарный дроп:\n" +
               $"  Адаптивная: {adaptive.LegendaryDropRate:P2} ({adaptive.LegendaryDrops}/{adaptive.TotalAttempts})\n" +
               $"  Random: {random.LegendaryDropRate:P2} ({random.LegendaryDrops}/{random.TotalAttempts})\n\n" +
               $"Серии неудач:\n" +
               $"  Адаптивная - средняя: {adaptive.AverageStreakLength:F1}, макс: {adaptive.MaxStreakLength}\n" +
               $"  Random - средняя: {random.AverageStreakLength:F1}, макс: {random.MaxStreakLength}\n\n" +
               $"Улучшение:\n" +
               $"  Сокращение макс. серии: {(1f - (float)adaptive.MaxStreakLength / random.MaxStreakLength):P1}\n" +
               $"  Сокращение средней серии: {(1f - adaptive.AverageStreakLength / random.AverageStreakLength):P1}";
    }
    
    /// <summary>
    /// Получить гистограмму длин серий
    /// </summary>
    public Dictionary<int, int> GetStreakHistogram(SimulationResults results)
    {
        var histogram = new Dictionary<int, int>();
        
        foreach (int length in results.FailureStreakLengths)
        {
            histogram[length] = histogram.GetValueOrDefault(length, 0) + 1;
        }
        
        return histogram;
    }
}

using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;
using System.Linq;
 
/// <summary>
/// UI панель для визуализации статистики адаптивной системы
/// </summary>
public class LootDebugUI : MonoBehaviour
{
    [Header("Ссылки на UI элементы")]
    [SerializeField] private Text _statsText;
    [SerializeField] private Text _histogramText;
    [SerializeField] private Text _comparisonText;
    [SerializeField] private Slider _probabilitySlider;
    [SerializeField] private Text _probabilityLabel;
    [SerializeField] private Image _streakIndicator;
    
    [Header("Цвета индикаторов")]
    [SerializeField] private Color _safeProbabilityColor = Color.green;
    [SerializeField] private Color _warningProbabilityColor = Color.yellow;
    [SerializeField] private Color _dangerProbabilityColor = Color.red;
    
    private LootSystemAdapter _lootSystem;
    private LootAnalytics _analytics;
    
    // Буфер для графика вероятностей
    private List<float> _probabilityHistory = new List<float>(100);
    
    public void Initialize(LootSystemAdapter lootSystem, LootAnalytics analytics)
    {
        _lootSystem = lootSystem;
        _analytics = analytics;
        
        // Подписываемся на события
        _lootSystem.OnProbabilityUpdated += UpdateProbabilityDisplay;
        _lootSystem.OnItemDropped += OnItemDropped;
    }
    
    private void OnDestroy()
    {
        if (_lootSystem != null)
        {
            _lootSystem.OnProbabilityUpdated -= UpdateProbabilityDisplay;
            _lootSystem.OnItemDropped -= OnItemDropped;
        }
    }
    
    /// <summary>
    /// Обновление отображения вероятности
    /// </summary>
    private void UpdateProbabilityDisplay(float probability, int streak)
    {
        // Обновляем слайдер
        if (_probabilitySlider != null)
        {
            _probabilitySlider.value = probability;
        }
        
        // Обновляем текст
        if (_probabilityLabel != null)
        {
            _probabilityLabel.text = $"Шанс легенды: {probability:P1}\nСерия: {streak}";
        }
        
        // Меняем цвет индикатора в зависимости от серии
        if (_streakIndicator != null)
        {
            Color color = streak switch
            {
                < 5 => _safeProbabilityColor,
                < 15 => _warningProbabilityColor,
                _ => _dangerProbabilityColor
            };
            _streakIndicator.color = color;
        }
        
        // Добавляем в историю для графика
        _probabilityHistory.Add(probability);
        if (_probabilityHistory.Count > 100)
        {
            _probabilityHistory.RemoveAt(0);
        }
    }
    
    private void OnItemDropped(LootItem item)
    {
        // Можно добавить визуальную реакцию на дроп
        if (item.Rarity == ItemRarity.Legendary)
        {
            Debug.Log($"<color=orange><b>ЛЕГЕНДА ВЫПАЛА!</b></color> {item.Name}");
        }
    }
    
    /// <summary>
    /// Обновление общей статистики
    /// </summary>
    public void UpdateStats()
    {
        if (_statsText == null || _lootSystem == null) return;
        
        var core = _lootSystem.GetCore();
        var (total, successes, failures, rate) = core.GetEventStatistics("legendary_drop");
        
        _statsText.text = $"=== СТАТИСТИКА СЕССИИ ===\n" +
                         $"Всего попыток: {_lootSystem.SessionAttempts}\n" +
                         $"Легенд выпало: {_lootSystem.SessionLegendaries}\n" +
                         $"Фактический %: {(_lootSystem.SessionAttempts > 0 ? (float)_lootSystem.SessionLegendaries / _lootSystem.SessionAttempts : 0):P2}\n" +
                         $"Текущая серия: {core.GetFailureStreak("legendary_drop")}\n\n" +
                         $"=== ОБЩАЯ СТАТИСТИКА ===\n" +
                         $"Всего событий: {core.TotalEvents}\n" +
                         $"Успехов: {core.TotalSuccesses}\n" +
                         $"Неудач: {core.TotalFailures}";
    }
    
    /// <summary>
    /// Показать гистограмму серий
    /// </summary>
    public void DisplayHistogram(Dictionary<int, int> histogram)
    {
        if (_histogramText == null) return;
        
        var sorted = histogram.OrderBy(x => x.Key).ToList();
        string text = "=== ГИСТОГРАММА СЕРИЙ НЕУДАЧ ===\n";
        
        int maxCount = histogram.Values.Max();
        foreach (var pair in sorted.Take(20)) // Показываем первые 20
        {
            int barLength = (int)(30f * pair.Value / maxCount);
            string bar = new string('█', barLength);
            text += $"{pair.Key,3}: {bar} ({pair.Value})\n";
        }
        
        _histogramText.text = text;
    }
    
    /// <summary>
    /// Показать сравнительный отчёт
    /// </summary>
    public void DisplayComparison(string report)
    {
        if (_comparisonText != null)
        {
            _comparisonText.text = report;
        }
    }
}

using UnityEngine;
using System.Collections;
 
/// <summary>
/// Симулятор для массового тестирования адаптивной системы
/// </summary>
public class LootSimulator : MonoBehaviour
{
    [Header("Ссылки")]
    [SerializeField] private LootSystemAdapter _lootSystem;
    [SerializeField] private AdaptiveConfiguration _config;
    [SerializeField] private LootDebugUI _debugUI;
    
    [Header("Параметры симуляции")]
    [SerializeField] private int _simulationIterations = 1000;
    [SerializeField] private bool _runOnStart = false;
    
    private LootAnalytics _analytics;
    
    private void Start()
    {
        _analytics = new LootAnalytics(_lootSystem.GetCore());
        _debugUI.Initialize(_lootSystem, _analytics);
        
        if (_runOnStart)
        {
            StartCoroutine(RunFullSimulation());
        }
    }
    
    /// <summary>
    /// Запуск полной симуляции с обеими системами
    /// </summary>
    public IEnumerator RunFullSimulation()
    {
        Debug.Log($"<b>Запуск симуляции: {_simulationIterations} итераций</b>");
        
        yield return new WaitForSeconds(0.5f);
        
        // Симуляция с адаптивной системой
        Debug.Log("Выполняется симуляция с адаптивной системой...");
        var adaptiveResults = _analytics.SimulateAdaptive(
            _simulationIterations,
            _config.legendaryDropChance,
            _config.rareDropChance,
            _config.GetLegendarySettings()
        );
        
        yield return new WaitForSeconds(0.5f);
        
        // Симуляция с чистым Random
        Debug.Log("Выполняется симуляция с чистым Random...");
        var randomResults = _analytics.SimulateRandom(
            _simulationIterations,
            _config.legendaryDropChance,
            _config.rareDropChance
        );
        
        yield return new WaitForSeconds(0.5f);
        
        // Выводим результаты
        string report = _analytics.GetComparisonReport();
        Debug.Log($"\n{report}\n");
        
        // Обновляем UI
        _debugUI.DisplayComparison(report);
        
        var adaptiveHistogram = _analytics.GetStreakHistogram(adaptiveResults);
        _debugUI.DisplayHistogram(adaptiveHistogram);
        
        Debug.Log("<color=green><b>Симуляция завершена!</b></color>");
    }
    
    /// <summary>
    /// Ручное открытие одного сундука
    /// </summary>
    public void OpenSingleChest()
    {
        var item = _lootSystem.OpenChest(playerLevel: 1);
        Debug.Log($"Выпал предмет: {item.Name} ({item.Rarity})");
        
        _debugUI.UpdateStats();
    }
    
    /// <summary>
    /// Открыть N сундуков подряд
    /// </summary>
    public void OpenMultipleChests(int count)
    {
        StartCoroutine(OpenChestsCoroutine(count));
    }
    
    private IEnumerator OpenChestsCoroutine(int count)
    {
        Debug.Log($"Открываем {count} сундуков...");
        
        for (int i = 0; i < count; i++)
        {
            _lootSystem.OpenChest(playerLevel: 1);
            
            // Небольшая задержка для визуализации
            if (i % 10 == 0)
            {
                _debugUI.UpdateStats();
                yield return new WaitForSeconds(0.1f);
            }
        }
        
        _debugUI.UpdateStats();
        Debug.Log($"<color=cyan>Открыто {count} сундуков</color>");
    }
    
    /// <summary>
    /// Сброс всей статистики
    /// </summary>
    public void ResetAllStats()
    {
        _lootSystem.ResetStats();
        _debugUI.UpdateStats();
        Debug.Log("Статистика сброшена");
    }
}

using UnityEngine;
using UnityEngine.UI;
 
/// <summary>
/// Главный контроллер демонстрационного приложения.
/// Управляет всеми компонентами и UI.
/// </summary>
public class AdaptiveLootDemo : MonoBehaviour
{
    [Header("Компоненты системы")]
    [SerializeField] private LootSystemAdapter _lootSystem;
    [SerializeField] private LootSimulator _simulator;
    [SerializeField] private LootDebugUI _debugUI;
    
    [Header("UI кнопки")]
    [SerializeField] private Button _openChestButton;
    [SerializeField] private Button _open10ChestsButton;
    [SerializeField] private Button _open100ChestsButton;
    [SerializeField] private Button _runSimulationButton;
    [SerializeField] private Button _resetButton;
    
    [Header("Режимы работы")]
    [SerializeField] private Toggle _adaptiveToggle;
    [SerializeField] private Text _modeLabel;
    
    private void Start()
    {
        SetupButtons();
        UpdateModeLabel();
    }
    
    private void SetupButtons()
    {
        if (_openChestButton != null)
        {
            _openChestButton.onClick.AddListener(() => _simulator.OpenSingleChest());
        }
        
        if (_open10ChestsButton != null)
        {
            _open10ChestsButton.onClick.AddListener(() => _simulator.OpenMultipleChests(10));
        }
        
        if (_open100ChestsButton != null)
        {
            _open100ChestsButton.onClick.AddListener(() => _simulator.OpenMultipleChests(100));
        }
        
        if (_runSimulationButton != null)
        {
            _runSimulationButton.onClick.AddListener(() => 
                StartCoroutine(_simulator.RunFullSimulation()));
        }
        
        if (_resetButton != null)
        {
            _resetButton.onClick.AddListener(() => _simulator.ResetAllStats());
        }
        
        if (_adaptiveToggle != null)
        {
            _adaptiveToggle.onValueChanged.AddListener(OnAdaptiveModeChanged);
        }
    }
    
    private void OnAdaptiveModeChanged(bool isAdaptive)
    {
        // Здесь можно переключать режимы работы
        UpdateModeLabel();
        Debug.Log($"Режим изменён: {(isAdaptive ? "Адаптивный" : "Чистый Random")}");
    }
    
    private void UpdateModeLabel()
    {
        if (_modeLabel != null && _adaptiveToggle != null)
        {
            _modeLabel.text = _adaptiveToggle.isOn ? "АДАПТИВНЫЙ РЕЖИМ" : "RANDOM РЕЖИМ";
            _modeLabel.color = _adaptiveToggle.isOn ? Color.green : Color.gray;
        }
    }
    
    private void Update()
    {
        // Горячие клавиши для быстрого тестирования
        if (Input.GetKeyDown(KeyCode.Space))
        {
            _simulator.OpenSingleChest();
        }
        
        if (Input.GetKeyDown(KeyCode.Alpha1))
        {
            _simulator.OpenMultipleChests(10);
        }
        
        if (Input.GetKeyDown(KeyCode.Alpha2))
        {
            _simulator.OpenMultipleChests(100);
        }
        
        if (Input.GetKeyDown(KeyCode.S))
        {
            StartCoroutine(_simulator.RunFullSimulation());
        }
        
        if (Input.GetKeyDown(KeyCode.R))
        {
            _simulator.ResetAllStats();
        }
    }
}

using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;
 
/// <summary>
/// Расширенный визуальный дебаггер с графиками изменения вероятностей
/// </summary>
public class AdvancedLootVisualizer : MonoBehaviour
{
    [Header("График вероятностей")]
    [SerializeField] private RectTransform _graphContainer;
    [SerializeField] private GameObject _graphPointPrefab;
    
    private List<GameObject> _graphPoints = new List<GameObject>();
    private List<float> _probabilityData = new List<float>();
    private const int MAX_GRAPH_POINTS = 50;
    
    /// <summary>
    /// Добавить точку на график
    /// </summary>
    public void AddProbabilityPoint(float probability)
    {
        _probabilityData.Add(probability);
        
        if (_probabilityData.Count > MAX_GRAPH_POINTS)
        {
            _probabilityData.RemoveAt(0);
        }
        
        RedrawGraph();
    }
    
    private void RedrawGraph()
    {
        if (_graphContainer == null || _graphPointPrefab == null) return;
        
        // Очищаем старые точки
        foreach (var point in _graphPoints)
        {
            Destroy(point);
        }
        _graphPoints.Clear();
        
        // Рисуем новые точки
        float width = _graphContainer.rect.width;
        float height = _graphContainer.rect.height;
        
        for (int i = 0; i < _probabilityData.Count; i++)
        {
            float x = (i / (float)MAX_GRAPH_POINTS) * width;
            float y = _probabilityData[i] * height;
            
            var point = Instantiate(_graphPointPrefab, _graphContainer);
            var rectTransform = point.GetComponent<RectTransform>();
            
            if (rectTransform != null)
            {
                rectTransform.anchoredPosition = new Vector2(x, y);
            }
            
            // Цвет точки зависит от вероятности
            var image = point.GetComponent<Image>();
            if (image != null)
            {
                image.color = Color.Lerp(Color.white, Color.red, _probabilityData[i]);
            }
            
            _graphPoints.Add(point);
        }
    }
    
    /// <summary>
    /// Очистка графика
    /// </summary>
    public void ClearGraph()
    {
        _probabilityData.Clear();
        
        foreach (var point in _graphPoints)
        {
            Destroy(point);
        }
        _graphPoints.Clear();
    }
}