public class DPS calculator
{
    public float CalculateDPS(WeaponStats weapon, CharacterStats character)
    {
        // 基础伤害
        float baseDamage = weapon.baseDamage + character.strength * 0.5f;

        // 攻击速度
        float attackSpeed = weapon.attackSpeed *
                           (1 + character.attackSpeedBonus);

        // 暴击期望
        float critChance = Mathf.Clamp01(
            weapon.critChance + character.critChanceBonus);
        float critDamage = weapon.critDamage + character.critDamageBonus;
        float critMultiplier = 1 + critChance * critDamage;

        // 元素/属性加成
        float elementalBonus = 1 + GetElementalBonus(weapon, character);

        // 敌人防御减免
        float defenseReduction = CalculateDefenseReduction(
            baseDamage, character.targetDefense);

        // 最终 DPS
        float dps = baseDamage * attackSpeed * critMultiplier *
                   elementalBonus * defenseReduction;

        return dps;
    }

    private float CalculateDefenseReduction(float damage, float defense)
    {
        // 常见防御公式：伤害 × 100 / (100 + 防御)
        return 100f / (100f + defense);
    }

    private float GetElementalBonus(WeaponStats weapon,
                                     CharacterStats character)
    {
        // 元素相克系统
        return 0f;
    }
}

public class DifficultyConfig
{
    public int level;               // 关卡/层数

    // 敌人参数
    public float enemyHPScale;      // 敌人血量系数
    public float enemyDamageScale;  // 敌人伤害系数
    public int enemyCountBonus;     // 敌人数量加成
    public float eliteChance;       // 精英怪出现概率

    // 玩家参数
    public float resourceConsumption; // 资源消耗系数
    public float healingEffectiveness; // 治疗效果

    // 环境参数
    public int checkpointInterval;  // 存档点间隔
    public float timeLimit;         // 时间限制（0 = 无限制）
}

public class DifficultyCurve
{
    public DifficultyConfig GetConfig(int level)
    {
        var config = new DifficultyConfig();
        config.level = level;

        // 敌人血量：指数增长
        config.enemyHPScale = Mathf.Pow(1.15f, level);

        // 敌人伤害：线性 + 阶梯
        config.enemyDamageScale = 1f + level * 0.1f;
        if (level >= 10) config.enemyDamageScale += 0.5f;
        if (level >= 20) config.enemyDamageScale += 1.0f;

        // 敌人数量：阶梯增长
        config.enemyCountBonus = level / 5;

        // 精英概率：线性增长，有上限
        config.eliteChance = Mathf.Min(0.05f + level * 0.02f, 0.5f);

        // 资源消耗：线性增长
        config.resourceConsumption = 1f + level * 0.05f;

        // 存档点间隔：逐渐增加
        config.checkpointInterval = 3 + level / 3;

        return config;
    }
}

public class DynamicDifficulty : MonoBehaviour
{
    private int _deathsInRow = 0;        // 连续死亡次数
    private int _killsWithoutDamage = 0; // 无伤击杀数
    private float _averageCompletionTime; // 平均通关时间

    [Header("调整参数")]
    public float difficultyReductionPerDeath = 0.05f; // 每次死亡降低 5%
    public float maxReduction = 0.3f;                  // 最多降低 30%
    public float difficultyIncreasePerKill = 0.02f;    // 每次无伤击杀增加 2%
    public float maxIncrease = 0.2f;                   // 最多增加 20%

    private float _currentAdjustment = 0f;

    public void OnPlayerDeath()
    {
        _deathsInRow++;
        _killsWithoutDamage = 0;

        // 连续死亡，降低难度
        _currentAdjustment -= difficultyReductionPerDeath;
        _currentAdjustment = Mathf.Max(_currentAdjustment, -maxReduction);

        ApplyDifficultyAdjustment();
    }

    public void OnEnemyKilled(bool playerTookDamage)
    {
        _deathsInRow = 0;

        if (!playerTookDamage)
        {
            _killsWithoutDamage++;

            // 连续无伤击杀，增加难度
            if (_killsWithoutDamage >= 5)
            {
                _currentAdjustment += difficultyIncreasePerKill;
                _currentAdjustment = Mathf.Min(_currentAdjustment, maxIncrease);
                ApplyDifficultyAdjustment();
            }
        }
    }

    private void ApplyDifficultyAdjustment()
    {
        // 调整敌人血量
        EnemyManager.Instance.SetHealthMultiplier(
            1f + _currentAdjustment);

        // 调整敌人伤害
        EnemyManager.Instance.SetDamageMultiplier(
            1f + _currentAdjustment);

        // 调整玩家伤害
        PlayerStats.Instance.SetDamageMultiplier(
            1f - _currentAdjustment * 0.5f); // 玩家伤害调整幅度较小
    }

    // 获取当前难度调整（用于 UI 显示，可选）
    public float GetCurrentAdjustment()
    {
        return _currentAdjustment;
    }
}

public class EconomyBalancer
{
    // 监控经济健康度
    public class EconomyMetrics
    {
        public float averageGoldPerHour;    // 平均每小时金币获取
        public float averageGoldSpentPerHour; // 平均每小时金币消耗
        public float inflationRate;          // 通货膨胀率
        public float giniCoefficient;        // 基尼系数（贫富差距）
    }

    public void AdjustEconomy(EconomyMetrics metrics)
    {
        float targetGoldPerHour = 100f;
        float targetRatio = 0.8f; // 消耗/获取 = 80%

        // 如果获取过快，降低掉落或提高消耗
        if (metrics.averageGoldPerHour > targetGoldPerHour * 1.2f)
        {
            // 方案 1: 降低敌人掉落
            LootTable.Instance.SetGlobalDropMultiplier(0.9f);

            // 方案 2: 提高商店价格
            ShopManager.Instance.SetPriceMultiplier(1.1f);
        }

        // 如果消耗过少（玩家囤积），增加消耗点
        float currentRatio = metrics.averageGoldSpentPerHour /
                            metrics.averageGoldPerHour;
        if (currentRatio < targetRatio * 0.8f)
        {
            // 增加新的消耗点（如限时商店、税收）
            EnableGoldSinkEvents();
        }
    }
}

public class ShopPricing
{
    // 基于价值的定价
    public int CalculatePrice(ItemStats stats)
    {
        int basePrice = 0;

        // 属性贡献
        basePrice += (int)(stats.attackPower * 5f);
        basePrice += (int)(stats.defense * 4f);
        basePrice += (int)(stats.maxHP * 0.5f);
        basePrice += (int)(stats.critChance * 100f);

        // 稀有度系数
        float rarityMultiplier = GetRarityMultiplier(stats.rarity);
        basePrice = (int)(basePrice * rarityMultiplier);

        // 供需调整（可选）
        basePrice = (int)(basePrice * GetSupplyDemandMultiplier(stats));

        return basePrice;
    }

    private float GetRarityMultiplier(Rarity rarity)
    {
        switch (rarity)
        {
            case Rarity.Common: return 1.0f;
            case Rarity.Uncommon: return 1.5f;
            case Rarity.Rare: return 2.5f;
            case Rarity.Epic: return 4.0f;
            case Rarity.Legendary: return 8.0f;
            default: return 1.0f;
        }
    }
}

public class ScarcitySystem
{
    // 限时商品
    public class LimitedTimeOffer
    {
        public Item item;
        public float discount;       // 折扣 (0.3 = 7 折)
        public float timeRemaining;  // 剩余时间（秒）
        public int stockLimit;       // 库存限制
    }

    // 稀缺性提示（增加购买紧迫感）
    public void ShowScarcityIndicators(Item item)
    {
        if (item.stockRemaining <= 3)
            ShowUI("仅剩 " + item.stockRemaining + " 件！");

        if (item.isLimitedTime)
            ShowUI("限时优惠: " + FormatTime(item.timeRemaining));
    }
}

public class LevelingSystem
{
    public int GetRequiredXP(int level)
    {
        if (level <= 10)
            return 100 + (level - 1) * 20;
        if (level <= 20)
            return 300 + (level - 11) * 50;
        if (level <= 30)
            return 800 + (level - 21) * 100;
        return 1800 + (level - 31) * 200;
    }

    public int GetTotalXPForLevel(int targetLevel)
    {
        int total = 0;
        for (int i = 1; i < targetLevel; i++)
            total += GetRequiredXP(i);
        return total;
    }

    public int GetLevelFromXP(int currentXP)
    {
        int level = 1;
        int xpNeeded = GetRequiredXP(level);

        while (currentXP >= xpNeeded && level < 50)
        {
            currentXP -= xpNeeded;
            level++;
            xpNeeded = GetRequiredXP(level);
        }

        return level;
    }
}

public class SkillTree
{
    public class SkillNode
    {
        public string id;
        public string name;
        public string description;
        public int maxRank;          // 最大等级
        public int currentRank;
        public int costPerRank;      // 每级技能点消耗
        public string[] prerequisites; // 前置技能 ID
        public SkillEffect[] effects;
    }

    public bool CanLearnSkill(string skillId, int availablePoints)
    {
        var skill = GetSkill(skillId);

        // 检查技能点
        if (availablePoints < skill.costPerRank)
            return false;

        // 检查是否已满级
        if (skill.currentRank >= skill.maxRank)
            return false;

        // 检查前置条件
        foreach (var prereqId in skill.prerequisites)
        {
            var prereq = GetSkill(prereqId);
            if (prereq.currentRank == 0)
                return false;
        }

        return true;
    }

    private SkillNode GetSkill(string id) { return null; }
}

public enum EnemyRole
{
    Grunt,      // 小兵：低血量，低伤害，数量多
    Elite,      // 精英：中等属性，特殊能力
    Tank,       // 坦克：高血量，低伤害
    GlassCannon,// 玻璃大炮：高伤害，低血量
    Support,    // 辅助：治疗/增益其他敌人
    Boss        // Boss：综合属性高，多阶段
}

public class EnemyConfig
{
    public EnemyRole role;
    public float baseHP;
    public float baseDamage;
    public float moveSpeed;
    public float attackRange;
    public float attackCooldown;
    public string[] abilities;
}

public class AbilityCooldown
{
    public float baseCooldown;       // 基础冷却（秒）
    public float cooldownReduction;  // 冷却缩减（%）

    public float GetEffectiveCooldown()
    {
        // 冷却缩减有上限（通常 40%）
        float reduction = Mathf.Min(cooldownReduction, 0.4f);
        return baseCooldown * (1 - reduction);
    }

    // 示例：
    // 基础冷却 10 秒，冷却缩减 30%
    // 实际冷却 = 10 × (1 - 0.3) = 7 秒
}

public class PositiveFeedbackController
{
    public float maxAdvantage = 2.0f;      // 最大优势倍数
    public float diminishingReturns = 0.8f; // 收益递减系数

    public float CalculateBonus(float currentAdvantage)
    {
        // 优势越大，额外收益越小
        if (currentAdvantage > 1.5f)
        {
            float excess = currentAdvantage - 1.5f;
            return 1.5f + excess * diminishingReturns;
        }
        return currentAdvantage;
    }
}

public class BalanceTestSuite
{
    // 模拟 1000 场战斗，统计胜率
    public void SimulateCombat(int iterations = 1000)
    {
        int playerWins = 0;
        int enemyWins = 0;

        for (int i = 0; i < iterations; i++)
        {
            var result = SimulateOneCombat();
            if (result.playerWon)
                playerWins++;
            else
                enemyWins++;
        }

        float winRate = (float)playerWins / iterations;
        Debug.Log($"玩家胜率: {winRate * 100:F1}%");

        // 目标胜率：50-70%（根据游戏类型调整）
        if (winRate < 0.5f || winRate > 0.7f)
            Debug.LogWarning("胜率偏离目标范围！");
    }

    // 极端值测试
    public void TestEdgeCases()
    {
        // 最大伤害 vs 最小血量
        var maxDamage = WeaponDB.GetMaxDamage();
        var minHP = EnemyDB.GetMinHP();
        bool oneShot = maxDamage >= minHP;
        Debug.Log($"最强武器能否秒杀最弱敌人: {oneShot}");

        // 最小伤害 vs 最大血量
        var minDamage = WeaponDB.GetMinDamage();
        var maxHP = EnemyDB.GetMaxHP();
        int hitsToKill = Mathf.CeilToInt(maxHP / minDamage);
        Debug.Log($"最弱武器击杀最强敌人需要 {hitsToKill} 次攻击");
    }

    private CombatResult SimulateOneCombat()
    {
        return new CombatResult { playerWon = true };
    }
}

public class AnalyticsTracker
{
    // 追踪关键指标
    public void TrackCombatEnd(bool playerWon, float duration,
                                int playerLevel, string enemyType)
    {
        Analytics.LogEvent("combat_end", new Dictionary<string, object>
        {
            { "player_won", playerWon },
            { "duration_seconds", duration },
            { "player_level", playerLevel },
            { "enemy_type", enemyType }
        });
    }

    // 分析数据
    public void AnalyzeDifficultyCurve()
    {
        // 按关卡统计胜率
        var winRatesByLevel = Analytics.GetWinRatesByLevel();

        foreach (var kvp in winRatesByLevel)
        {
            Debug.Log($"关卡 {kvp.Key}: 胜率 {kvp.Value * 100:F1}%");

            // 胜率过低（< 40%）或过高（> 80%）都需要调整
            if (kvp.Value < 0.4f)
                Debug.LogWarning($"关卡 {kvp.Key} 太难！");
            if (kvp.Value > 0.8f)
                Debug.LogWarning($"关卡 {kvp.Key} 太简单！");
        }
    }
}

public class ABTest
{
    public enum Variant { A, B }

    public Variant GetUserVariant(string userId)
    {
        // 根据用户 ID 哈希分配到不同组
        int hash = userId.GetHashCode();
        return (hash % 2 == 0) ? Variant.A : Variant.B;
    }

    public float GetParameterValue(string paramName, Variant variant)
    {
        switch (paramName)
        {
            case "enemy_hp_multiplier":
                return variant == Variant.A ? 1.0f : 1.2f;
            case "player_damage_multiplier":
                return variant == Variant.A ? 1.0f : 0.9f;
            default:
                return 1.0f;
        }
    }

    // 分析结果
    public void AnalyzeResults()
    {
        var retentionA = Analytics.GetRetention(Variant.A);
        var retentionB = Analytics.GetRetention(Variant.B);

        Debug.Log($"A 组次留: {retentionA * 100:F1}%");
        Debug.Log($"B 组次留: {retentionB * 100:F1}%");

        // 选择留存更高的方案
        var winner = retentionA > retentionB ? Variant.A : Variant.B;
        Debug.Log($"胜出方案: {winner}");
    }
}

## 平衡性调整 v1.2.3

### 武器调整
- **铁剑** 基础伤害从 10 提升至 12
  - 原因：铁剑在同级武器中 DPS 偏低，使用率仅 8%
  - 预期：DPS 提升 20%，使用率提升至 15-20%

- **火焰法杖** 火焰持续时间从 5 秒降低至 3 秒
  - 原因：火焰法杖的持续伤害过高，占法师玩家 70% 的输出
  - 预期：总 DPS 降低 15%，鼓励多样化武器选择

### 敌人调整
- **骷髅战士** 血量从 150 降低至 120
  - 原因：第 3 关胜率仅 45%，低于目标的 55%
  - 预期：第 3 关胜率提升至 55-60%

### 经济调整
- **商店价格** 所有物品价格降低 10%
  - 原因：玩家金币囤积率过高，消耗率仅 60%
  - 预期：消耗率提升至 75%