特效与打击感深度研究

打击感强度 = (视觉冲击力 × 音效冲击力) + 顿帧时长 + 屏幕震动幅度

理想配比:
- 小攻击: 小特效 + 轻音效 + 无顿帧 + 无震动
- 中攻击: 中特效 + 重音效 + 1-2帧顿帧 + 轻震动
- 大招: 巨大特效 + 爆炸音效 + 3-5帧顿帧 + 强震动

震动强度 = 振幅 (Amplitude) × 频率 (Frequency) × 衰减 (Decay)

振幅 (Amplitude):
- 轻微: 2-5 像素
- 中等: 5-10 像素
- 强烈: 10-20 像素
- 极限: 20+ 像素（慎用，容易晕）

频率 (Frequency):
- 低频 (5-10 Hz): 沉重感（重武器）
- 中频 (10-20 Hz): 平衡
- 高频 (20-30 Hz): 激烈感（爆炸）

衰减 (Decay):
- 线性衰减: 平滑但平淡
- 指数衰减: 自然真实（推荐）
- 弹性衰减: 有韵律感

振幅
  │
  │ ╱╲    指数衰减（推荐）
  │╱  ╲___
  │      ╲___
  └────────────────► 时间
       0.1s  0.3s

振幅
  │
  │ ╱╲╱╲  弹性衰减（夸张）
  │╱╲  ╲╱╲
  │      ╲╱_
  └────────────────► 时间

攻击类型          帧数  时长(60fps)
──────────────────────────────
轻击              1-2   16-33ms
重击              2-3   33-50ms
暴击              3-4   50-66ms
必杀技            4-6   66-100ms
终结技            6-10  100-166ms

⚠️ 警告: 超过 10 帧（166ms）会感觉"卡"

命中瞬间:
- 攻击者: 顿帧 3 帧
- 被击者: 顿帧 5 帧
- 背景/其他敌人: 正常运行

效果: 强调冲击，但不影响整体节奏

时间线:
0ms:  攻击动画触发
      ↓
50ms: 武器接触敌人
      ↓
50ms: 【顿帧开始】+ 音效播放
      ↓
83ms: 【顿帧结束】（2 帧 @ 60fps）
      ↓
84ms: 受击动画 + 特效爆发

性能预算:
- 同屏粒子总数: < 200 个（低端设备）
- 单个粒子系统: < 50 个粒子
- 粒子贴图大小: 128×128 或更小
- 避免透明度叠加（Overdraw 杀手）

优化策略:
1. 使用对象池（不要频繁 Instantiate）
2. 粒子 LOD（远处敌人减少粒子）
3. 关键时刻才爆发（不要持续发射）

攻击音效 = 基础层 + 冲击层 + 环境层

示例 - 重剑斩击:
基础层: "嗡——" (挥舞破风声)
冲击层: "Duang!" (金属撞击)
环境层: "Boom..." (低频残响)

Pitch (音调):
- 随机 ±10%: 避免重复感
- 暴击 +20%: 更清脆
- 重武器 -20%: 更沉重

Volume (音量):
- 伤害越高，音量越大
- 但最大不超过 0 dB（避免爆音）

效果器:
- 低通滤波: 水下/慢动作效果
- 镶边 (Flanger): 科幻武器
- 混响 (Reverb): 空间感

❌ 糟糕: 音效滞后 100ms
   （玩家感觉"软绵绵"）

✅ 良好: 音效提前 16ms (1帧)
   （大脑自动补偿，感觉完美同步）

✅ 最佳: 音效精确同步（0ms 误差）
   （需要精细调整）

┌─────────────────────────────────────┐
│ 第 1 层：基础反馈（所有攻击）        │
│ - 攻击动画                          │
│ - 小型音效                          │
├─────────────────────────────────────┤
│ 第 2 层：强化反馈（重击/技能）       │
│ - 粒子特效                          │
│ - 顿帧 2-3 帧                       │
│ - 轻微震动                          │
├─────────────────────────────────────┤
│ 第 3 层：爆发反馈（大招/暴击）       │
│ - 全屏特效                          │
│ - 顿帧 4-6 帧                       │
│ - 强烈震动                          │
│ - 慢动作（可选）                    │
└─────────────────────────────────────┘

[CreateAssetMenu(fileName = "HitFeedback", menuName = "VFX/Hit Feedback")]
public class HitFeedbackConfig : ScriptableObject
{
    [Header("视觉反馈")]
    public GameObject hitEffectPrefab;
    public Vector3 effectScale = Vector3.one;
    public float effectDuration = 0.5f;

    [Header("屏幕震动")]
    public bool enableScreenShake = true;
    public float shakeIntensity = 5f;     // 振幅（像素）
    public float shakeFrequency = 15f;    // 频率（Hz）
    public float shakeDuration = 0.15f;   // 持续时间
    public AnimationCurve shakeDecay;     // 衰减曲线

    [Header("顿帧")]
    public bool enableHitstop = true;
    public int hitstopFrames = 2;         // 顿帧帧数
    public bool freezeAttacker = true;    // 是否冻结攻击者
    public bool freezeVictim = true;      // 是否冻结被击者

    [Header("音效")]
    public AudioClip hitSound;
    public float pitchVariation = 0.1f;   // 音调随机 ±10%
    public float volumeScale = 1.0f;

    [Header("震动反馈（移动端）")]
    public bool enableHapticFeedback = true;
    public HapticFeedbackType hapticType = HapticFeedbackType.Medium;
}

public enum HapticFeedbackType
{
    Light,    // 轻微震动（小攻击）
    Medium,   // 中等震动（重击）
    Heavy     // 强烈震动（必杀）
}

public class GameFeelManager : MonoBehaviour
{
    public static GameFeelManager Instance { get; private set; }

    [Header("屏幕震动")]
    private Camera mainCamera;
    private Vector3 originalCameraPos;
    private Coroutine shakeCoroutine;

    [Header("时间控制")]
    private float defaultTimeScale = 1.0f;
    private Coroutine hitstopCoroutine;

    void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            mainCamera = Camera.main;
            originalCameraPos = mainCamera.transform.localPosition;
        }
        else
        {
            Destroy(gameObject);
        }
    }

    public void TriggerHitFeedback(HitFeedbackConfig config, Vector3 hitPosition)
    {
        // 1. 特效
        if (config.hitEffectPrefab != null)
        {
            SpawnHitEffect(config, hitPosition);
        }

        // 2. 屏幕震动
        if (config.enableScreenShake)
        {
            ScreenShake(config.shakeIntensity, config.shakeFrequency,
                        config.shakeDuration, config.shakeDecay);
        }

        // 3. 顿帧
        if (config.enableHitstop)
        {
            Hitstop(config.hitstopFrames);
        }

        // 4. 音效
        if (config.hitSound != null)
        {
            PlayHitSound(config);
        }

        // 5. 震动反馈
        if (config.enableHapticFeedback && Application.isMobilePlatform)
        {
            TriggerHaptic(config.hapticType);
        }
    }

    private void SpawnHitEffect(HitFeedbackConfig config, Vector3 position)
    {
        var effect = Instantiate(config.hitEffectPrefab, position, Quaternion.identity);
        effect.transform.localScale = config.effectScale;
        Destroy(effect, config.effectDuration);
    }

    public void ScreenShake(float intensity, float frequency, float duration, AnimationCurve decay = null)
    {
        if (shakeCoroutine != null)
        {
            StopCoroutine(shakeCoroutine);
        }

        shakeCoroutine = StartCoroutine(ScreenShakeCoroutine(intensity, frequency, duration, decay));
    }

    private IEnumerator ScreenShakeCoroutine(float intensity, float frequency, float duration, AnimationCurve decay)
    {
        float elapsed = 0f;

        while (elapsed < duration)
        {
            float progress = elapsed / duration;

            // 应用衰减曲线
            float currentIntensity = intensity;
            if (decay != null)
            {
                currentIntensity *= decay.Evaluate(progress);
            }
            else
            {
                // 默认指数衰减
                currentIntensity *= Mathf.Exp(-5 * progress);
            }

            // 计算震动偏移
            float offsetX = Mathf.PerlinNoise(elapsed * frequency, 0f) * 2f - 1f;
            float offsetY = Mathf.PerlinNoise(0f, elapsed * frequency) * 2f - 1f;

            Vector3 shakeOffset = new Vector3(
                offsetX * currentIntensity * 0.01f,
                offsetY * currentIntensity * 0.01f,
                0f
            );

            mainCamera.transform.localPosition = originalCameraPos + shakeOffset;

            elapsed += Time.unscaledDeltaTime;
            yield return null;
        }

        // 恢复原位
        mainCamera.transform.localPosition = originalCameraPos;
    }

    public void Hitstop(int frames)
    {
        if (hitstopCoroutine != null)
        {
            StopCoroutine(hitstopCoroutine);
        }

        hitstopCoroutine = StartCoroutine(HitstopCoroutine(frames));
    }

    private IEnumerator HitstopCoroutine(int frames)
    {
        // 保存当前时间缩放
        float originalTimeScale = Time.timeScale;

        // 冻结时间
        Time.timeScale = 0f;

        // 等待指定帧数（使用 unscaled time）
        float frameDuration = 1f / 60f;  // 假设 60fps
        yield return new WaitForSecondsRealtime(frames * frameDuration);

        // 恢复时间
        Time.timeScale = originalTimeScale;
    }

    private void PlayHitSound(HitFeedbackConfig config)
    {
        if (config.hitSound == null) return;

        // 随机音调变化
        float randomPitch = 1.0f + Random.Range(-config.pitchVariation, config.pitchVariation);

        // 播放音效
        AudioSource.PlayClipAtPoint(
            config.hitSound,
            mainCamera.transform.position,
            config.volumeScale
        );

        // 注意：PlayClipAtPoint 不支持 pitch，这里需要用 AudioSource 对象池
    }

    private void TriggerHaptic(HapticFeedbackType type)
    {
        #if UNITY_ANDROID || UNITY_IOS
        switch (type)
        {
            case HapticFeedbackType.Light:
                Handheld.Vibrate();
                break;
            case HapticFeedbackType.Medium:
                Handheld.Vibrate();
                break;
            case HapticFeedbackType.Heavy:
                Handheld.Vibrate();
                break;
        }
        #endif
    }

    // 慢动作效果
    public void SlowMotion(float timeScale, float duration)
    {
        StartCoroutine(SlowMotionCoroutine(timeScale, duration));
    }

    private IEnumerator SlowMotionCoroutine(float targetTimeScale, float duration)
    {
        float originalTimeScale = Time.timeScale;

        // 渐入慢动作
        float elapsed = 0f;
        while (elapsed < 0.1f)
        {
            Time.timeScale = Mathf.Lerp(originalTimeScale, targetTimeScale, elapsed / 0.1f);
            elapsed += Time.unscaledDeltaTime;
            yield return null;
        }

        Time.timeScale = targetTimeScale;

        // 维持慢动作
        yield return new WaitForSecondsRealtime(duration);

        // 渐出慢动作
        elapsed = 0f;
        while (elapsed < 0.1f)
        {
            Time.timeScale = Mathf.Lerp(targetTimeScale, originalTimeScale, elapsed / 0.1f);
            elapsed += Time.unscaledDeltaTime;
            yield return null;
        }

        Time.timeScale = originalTimeScale;
    }
}

public class VFXPool : MonoBehaviour
{
    private Dictionary<string, Queue<GameObject>> pools = new Dictionary<string, Queue<GameObject>>();

    public GameObject Spawn(GameObject prefab, Vector3 position, Quaternion rotation)
    {
        string key = prefab.name;

        if (!pools.ContainsKey(key))
        {
            pools[key] = new Queue<GameObject>();
        }

        GameObject obj;

        if (pools[key].Count > 0)
        {
            obj = pools[key].Dequeue();
            obj.transform.position = position;
            obj.transform.rotation = rotation;
            obj.SetActive(true);
        }
        else
        {
            obj = Instantiate(prefab, position, rotation);
        }

        return obj;
    }

    public void Recycle(GameObject obj, float delay = 0f)
    {
        StartCoroutine(RecycleAfterDelay(obj, delay));
    }

    private IEnumerator RecycleAfterDelay(GameObject obj, float delay)
    {
        yield return new WaitForSeconds(delay);

        obj.SetActive(false);

        string key = obj.name.Replace("(Clone)", "");
        if (!pools.ContainsKey(key))
        {
            pools[key] = new Queue<GameObject>();
        }

        pools[key].Enqueue(obj);
    }
}

public class ParticleLOD : MonoBehaviour
{
    private ParticleSystem ps;
    private Transform player;

    [Header("LOD 设置")]
    public float highDetailDistance = 10f;
    public float midDetailDistance = 20f;
    public float lowDetailDistance = 30f;

    public int highDetailCount = 50;
    public int midDetailCount = 20;
    public int lowDetailCount = 5;

    void Update()
    {
        if (player == null)
        {
            player = GameObject.FindGameObjectWithTag("Player").transform;
            return;
        }

        float distance = Vector3.Distance(transform.position, player.position);

        var main = ps.main;

        if (distance < highDetailDistance)
        {
            main.maxParticles = highDetailCount;
        }
        else if (distance < midDetailDistance)
        {
            main.maxParticles = midDetailCount;
        }
        else if (distance < lowDetailDistance)
        {
            main.maxParticles = lowDetailCount;
        }
        else
        {
            // 太远，直接停止
            ps.Stop();
        }
    }
}

Stinger（突刺）:
1. 冲刺动画播放（0ms）
2. 移动速度激增
3. 剑接触敌人（200ms）
4. 【顿帧 4 帧】
5. 音效 "CLANG!"
6. 敌人被击飞
7. 粒子爆发（火花 + 冲击波）
8. 屏幕轻微震动

Hellfire（地狱火）:
1. 蓄力动画
2. 屏幕变暗（后处理）
3. 慢动作 0.3x timeScale
4. 火柱爆发
5. 【顿帧 8 帧】
6. 音效 "BOOM!" + 低频混响
7. 强烈震动
8. 全屏粒子（火焰 + 烟雾）

攻击反馈（单个敌人）:
- 敌人闪白 1 帧
- "咔" 音效（清脆）
- 小型数字飘字

群体攻击（数十敌人）:
- 连续闪白形成"频闪"效果
- "咔咔咔咔" 连续音效
- 数字雨
- ⚠️ 无顿帧（避免卡顿）
- ⚠️ 无震动（太频繁会晕）

升级瞬间（重要时刻）:
- 【全屏闪光】
- 【时间暂停 0.5 秒】
- 升级音效 "DING!"
- UI 动画弹出

问题: 同时击中 50 个敌人
- 不能全部顿帧（会卡死）
- 不能全部震动（会晕）
- 粒子数会爆炸

解决方案:
- 只对"最近的 5 个"敌人播放完整特效
- 其他敌人只闪白 + 轻音效
- 音效使用"混合"而非叠加
- 粒子总数限制在 200 个以内

void FireWeapon()
{
    // 1. 播放开火动画
    animator.SetTrigger("Fire");

    // 2. 生成子弹
    SpawnBullet();

    // 3. 后坐力（相机反冲）
    Vector3 recoilDir = -transform.right;  // 后方
    CameraRecoil(recoilDir, recoilStrength, recoilDuration);

    // 4. 音效
    AudioManager.PlaySFX(gunfireSound);

    // 5. 弹壳抛出
    EjectCasing();

    // 6. 枪口火光
    muzzleFlash.Play();
}

void CameraRecoil(Vector3 direction, float strength, float duration)
{
    StartCoroutine(CameraRecoilCoroutine(direction, strength, duration));
}

IEnumerator CameraRecoilCoroutine(Vector3 dir, float strength, float duration)
{
    Vector3 startPos = cameraTransform.localPosition;
    Vector3 recoilPos = startPos + dir * strength;

    // 快速后退
    float elapsed = 0f;
    while (elapsed < duration * 0.3f)
    {
        cameraTransform.localPosition = Vector3.Lerp(startPos, recoilPos, elapsed / (duration * 0.3f));
        elapsed += Time.deltaTime;
        yield return null;
    }

    // 缓慢恢复
    elapsed = 0f;
    while (elapsed < duration * 0.7f)
    {
        cameraTransform.localPosition = Vector3.Lerp(recoilPos, startPos, elapsed / (duration * 0.7f));
        elapsed += Time.deltaTime;
        yield return null;
    }

    cameraTransform.localPosition = startPos;
}

攻击反馈速度:
- 顿帧只有 1-2 帧（极短）
- 震动只在暴击和必杀
- 粒子轻量级（每次 \<20 个）

流畅性优先:
- 攻击动画可以随时取消（冲刺取消）
- 无长时间顿帧（避免打断节奏）
- 连续攻击音效不叠加（只加强 volume）

但关键时刻爆发:
- 房间清空: 全屏闪光 + 音效
- Boss 阶段转换: 慢动作 + 强震动
- 死神降临: 时间暂停 + 特殊音乐

剑斩（普通攻击）:
第 1 击: 挥舞音 "whoosh"
第 2 击: 挥舞音 "whoosh" + 轻微撞击 "tink"
第 3 击: 挥舞音 "whoosh" + 重撞击 "CLANG"
（递进感）

暴击:
基础音效 + 额外"爆裂音" + 低频 "Boom"