EventHandlers.cs

using LabApi.Events.Arguments.PlayerEvents;
using LabApi.Events.Arguments.ServerEvents;
using LabApi.Features.Wrappers;
using LevelUp.PlayerData;
using PlayerRoles;
using PlayerStatsSystem;
using System;
using System.Collections.Generic;
using System.Linq;
using MEC;
using UnityEngine;
using Logger = LabApi.Features.Console.Logger;

namespace LevelUp;

public class EventHandlers
{
    // 静态列表，存储本回合已激活的发电机ID
    private readonly HashSet<int> ActivatedGenerators = new();

    private bool roundhasnotstarted = true;

    public class SCPDamageLog
    {
        public List<string> Attackers = new List<string>();
        public Dictionary<string, float> DamagePercent = new Dictionary<string, float>();
    }

    public Dictionary<string, SCPDamageLog> scpdamage = new();

    // Phase 3.1: 辅助击杀和连杀追踪
    private readonly Dictionary<string, HashSet<string>> playerDamageDealt = new(); // 玩家对目标造成的伤害记录
    private readonly Dictionary<string, List<DateTime>> playerKillTimes = new(); // 玩家击杀时间记录（用于连杀）
    private readonly Dictionary<string, HashSet<RoleTypeId>> playerKilledRoles = new(); // 玩家本回合击杀的角色类型

    // Phase 3.4: 存活时间协程
    private CoroutineHandle survivalRewardCoroutine;

    // Phase 4: 统计数据追踪
    private readonly Dictionary<string, DateTime> playerJoinTimes = new(); // 玩家加入时间

    /// <summary>
    /// 激活发电机时的经验处理
    /// </summary>
    /// <param name="ev">事件参数。</param>
    public void OnPlayerActivatingGenerator(PlayerActivatingGeneratorEventArgs ev)
    {
        // 获取发电机ID
        int generatorId = ev.Generator.Base.GetInstanceID();

        if (ev.Player == null || ev.Player.IsNpc || roundhasnotstarted)
            return;

        // 检查发电机是否在本回合被激活过
        if (ActivatedGenerators.Contains(generatorId))
        {
            if (LevelUp.Instance.Config.Debug)
                Logger.Debug($"发电机 {generatorId} 已在本回合被激活，不给予经验。");
            return;
        }

        ActivatedGenerators.Add(generatorId);

        string userId = ev.Player.UserId;

        // 从缓存中获取玩家数据，如果不存在则创建
        if (!LevelUp.Instance.PlayerDataCache.TryGetValue(userId, out DataTemplates playerData))
        {
            playerData = new DataTemplates { UserId = userId };
            LevelUp.Instance.PlayerDataCache[userId] = playerData;
            if (LevelUp.Instance.Config.Debug)
                Logger.Debug($"为玩家 {ev.Player.Nickname} ({userId}) 创建新的数据模板。");
        }

        // 从配置文件获取经验值
        int expGained = LevelUp.Instance.Config.expAmount.ActivatingGenerator;
        playerData.Experience += expGained;

        if (LevelUp.Instance.Config.Debug)
            Logger.Debug($"玩家 {ev.Player.Nickname} 激活发电机，获得 {expGained} 经验，当前经验: {playerData.Experience}。");

        // 提示信息处理
        string expGainedMessage = LevelUp.Instance.Translation.EventHintTrans.ActiveGenerator
                           .Replace("{exp}", expGained.ToString())
                           .Replace("{roleColor}", ev.Player.RoleBase.RoleColor.ToHex());

        ev.Player.SendHint(expGainedMessage, LevelUp.Instance.Config.showTime.gotexp);

        // 检查是否升级
        LevelUp.Instance.CheckForLevelUp(ev.Player, playerData);
    }

    /// <summary>
    /// 离开服务器保存玩家数据
    /// </summary>
    /// <param name="ev">事件参数</param>
    public void OnPlayerLeft(PlayerLeftEventArgs ev)
    {
        // Phase 4: 计算并累加游戏时长
        if (playerJoinTimes.TryGetValue(ev.Player.UserId, out DateTime joinTime))
        {
            int playTime = (int)(DateTime.Now - joinTime).TotalSeconds;

            if (LevelUp.Instance.PlayerDataCache.TryGetValue(ev.Player.UserId, out var playerData))
            {
                playerData.TotalPlayTime += playTime;

                if (LevelUp.Instance.Config.Debug)
                    Logger.Debug($"玩家 {ev.Player.Nickname} 本次游戏时长: {playTime} 秒，总时长: {playerData.TotalPlayTime} 秒");
            }

            playerJoinTimes.Remove(ev.Player.UserId);
        }

        LevelUp.Instance.SavePlayerData();
        if(LevelUp.Instance.Config.Debug)
            Logger.Debug($"玩家 {ev.Player.Nickname} 离开，所有数据已保存。");
    }

    /// <summary>
    /// 回合开始才允许添加hint
    /// </summary>
    public void OnServerRoundStarted()
    {
        roundhasnotstarted = false;
        ActivatedGenerators.Clear();

        // Phase 3: 清理追踪数据
        playerDamageDealt.Clear();
        playerKillTimes.Clear();
        playerKilledRoles.Clear();

        if (LevelUp.Instance.Config.Debug)
            Logger.Debug($"回合开始，发电机激活状态已重置。");

        foreach (Player player in Player.List)
        {
            Hints.AddLevelHint(player);
            // 初始化玩家名称前缀
            Hints.UpdatePlayerNameWithLevelPrefix(player);
            if (LevelUp.Instance.Config.Debug)
                Logger.Debug($"玩家 {player.Nickname} 加入，添加提示并设置等级前缀。");
        }

        // Phase 3.4: 启动存活时间奖励协程
        if (survivalRewardCoroutine.IsRunning)
            Timing.KillCoroutines(survivalRewardCoroutine);

        survivalRewardCoroutine = Timing.RunCoroutine(SurvivalRewardCoroutine());
    }

    /// <summary>
    /// 回合结束保存玩家数据
    /// </summary>
    /// <param name="ev">事件参数</param>
    public void OnServerRoundEnded(RoundEndedEventArgs ev)
    {
        // Phase 4: 回合结束统计展示
        DisplayRoundEndStats();

        // Phase 4: 更新所有参与玩家的游戏局数
        foreach (Player player in Player.List)
        {
            if (player == null || player.IsNpc) continue;

            if (LevelUp.Instance.PlayerDataCache.TryGetValue(player.UserId, out var playerData))
            {
                playerData.TotalGamesPlayed++;

                if (LevelUp.Instance.Config.Debug)
                    Logger.Debug($"玩家 {player.Nickname} 完成一局，总局数: {playerData.TotalGamesPlayed}");
            }
        }

        LevelUp.Instance.SavePlayerData();
        ActivatedGenerators.Clear();

        // Phase 3: 清理追踪数据
        playerDamageDealt.Clear();
        playerKillTimes.Clear();
        playerKilledRoles.Clear();

        // Phase 4: 清理加入时间记录
        playerJoinTimes.Clear();

        // 停止存活时间奖励协程
        if (survivalRewardCoroutine.IsRunning)
            Timing.KillCoroutines(survivalRewardCoroutine);

        if (LevelUp.Instance.Config.Debug)
            Logger.Debug($"回合结束，所有玩家数据已保存，发电机激活状态已重置。");

        Hints.RemoveAllHints();
        roundhasnotstarted = true;
    }

    /// <summary>
    /// Phase 4.4: 显示回合结束统计
    /// </summary>
    private void DisplayRoundEndStats()
    {
        // 创建临时统计字典（本局击杀数）
        Dictionary<string, int> roundKills = new Dictionary<string, int>();

        foreach (Player player in Player.List)
        {
            if (player == null || player.IsNpc) continue;

            if (LevelUp.Instance.PlayerDataCache.TryGetValue(player.UserId, out var playerData))
            {
                // 简单统计：使用当前连杀记录作为本局击杀的近似值
                if (playerKillTimes.TryGetValue(player.UserId, out var killTimes))
                {
                    roundKills[player.UserId] = killTimes.Count;
                }
            }
        }

        // 找到MVP（本局最高击杀）
        if (roundKills.Count > 0)
        {
            var mvp = roundKills.OrderByDescending(x => x.Value).First();
            Player mvpPlayer = Player.Get(mvp.Key);

            if (mvpPlayer != null && mvp.Value > 0)
            {
                string mvpMessage = $"\n<color=yellow>═══ 回合统计 ═══</color>\n" +
                    $"<color=green>MVP: {mvpPlayer.Nickname} ({mvp.Value}击杀)</color>";

                // 广播给所有玩家
                foreach (Player player in Player.List)
                {
                    if (player == null || player.IsNpc) continue;
                    player.SendBroadcast(mvpMessage, 10);
                }

                if (LevelUp.Instance.Config.Debug)
                    Logger.Debug($"回合MVP: {mvpPlayer.Nickname} ({mvp.Value}击杀)");
            }
        }
    }

    // 在OnPlayerJoined方法中添加名称前缀初始化
    public void OnPlayerJoined(PlayerJoinedEventArgs ev)
    {
        if (roundhasnotstarted) return;

        // Phase 4: 记录玩家加入时间
        playerJoinTimes[ev.Player.UserId] = DateTime.Now;

        Hints.AddLevelHint(ev.Player);
        // 初始化玩家名称前缀
        Hints.UpdatePlayerNameWithLevelPrefix(ev.Player);
        if (LevelUp.Instance.Config.Debug)
            Logger.Debug($"玩家 {ev.Player.Nickname} 加入，添加提示并设置等级前缀。");
    }

    /// <summary>
    /// 处理玩家击杀事件
    /// </summary>
    public void OnPlayerDeath(PlayerDeathEventArgs ev)
    {
        try
        {
            // 避免处理非玩家击杀或无效情况
            if (ev.Attacker == null || ev.Player == null)
                return;

            // Phase 4: 更新死亡统计
            if (!ev.Player.IsNpc)
            {
                if (!LevelUp.Instance.PlayerDataCache.TryGetValue(ev.Player.UserId, out var victimData))
                {
                    victimData = new DataTemplates { UserId = ev.Player.UserId };
                    LevelUp.Instance.PlayerDataCache[ev.Player.UserId] = victimData;
                }
                victimData.TotalDeaths++;

                if (LevelUp.Instance.Config.Debug)
                    Logger.Debug($"玩家 {ev.Player.Nickname} 死亡，总死亡数: {victimData.TotalDeaths}");
            }

            bool tgtwasSCP = ev.Player.IsSCP && ev.Player.Role != RoleTypeId.Scp0492;

        // 广播击杀信息给所有玩家
        Hints.BroadcastKillMessage(ev.Attacker, ev.Player);

        // 给击杀者添加经验
        string killerId = ev.Attacker.UserId;

        if (!LevelUp.Instance.PlayerDataCache.TryGetValue(killerId, out DataTemplates killerData))
        {
            killerData = new DataTemplates { UserId = killerId };
            LevelUp.Instance.PlayerDataCache[killerId] = killerData;
        }

        // Phase 3.3: SCP击杀人类使用不同经验值
        int killExp;
        if (ev.Attacker.IsSCP && !ev.Player.IsSCP)
        {
            killExp = LevelUp.Instance.Config.expAmount.ScpKillHuman;
        }
        else
        {
            killExp = LevelUp.Instance.Config.expAmount.KillingPlayer;
        }

        killerData.Experience += killExp;

        // Phase 4: 更新击杀统计
        killerData.TotalKills++;

        // 更新角色击杀统计
        string roleKey = ev.Player.Role.ToString();
        if (!killerData.KillsByRole.ContainsKey(roleKey))
            killerData.KillsByRole[roleKey] = 0;
        killerData.KillsByRole[roleKey]++;

        string expGainedMessage = LevelUp.Instance.Translation.EventHintTrans.KillPlayer
            .Replace("{exp}", killExp.ToString())
            .Replace("{roleColor}", ev.Attacker.RoleBase.RoleColor.ToHex());

        // 击杀玩家获得经验提示
        ev.Attacker.SendHint(expGainedMessage, LevelUp.Instance.Config.showTime.gotexp);

        if (LevelUp.Instance.Config.Debug)
            Logger.Debug($"玩家 {ev.Attacker.Nickname} 击杀了 {ev.Player.Nickname}，获得 {killExp} 经验");

        if(tgtwasSCP)
        {
            string tgt = ev.Player.UserId;
            // 安全检查：确保该SCP的伤害记录存在
            if (scpdamage.TryGetValue(tgt, out SCPDamageLog damageLog))
            {
                foreach(var p in damageLog.Attackers)
                {
                    if (!LevelUp.Instance.PlayerDataCache.TryGetValue(p, out var playerData))
                    {
                        playerData = new DataTemplates { UserId = p };
                        LevelUp.Instance.PlayerDataCache[p] = playerData;
                    }

                    // 安全获取伤害百分比
                    if (!damageLog.DamagePercent.TryGetValue(p, out float damagePercent))
                    {
                        if (LevelUp.Instance.Config.Debug)
                            Logger.Debug($"警告：玩家 {p} 在攻击者列表中，但没有伤害百分比记录");
                        continue;
                    }

                    int exp;
                    if (damagePercent < 5f)
                    {
                        exp = LevelUp.Instance.Config.expAmount.damageless5;
                    }
                    else
                    {
                        exp = (int)(LevelUp.Instance.Config.expAmount.times * damagePercent);
                    }

                    playerData.Experience += exp;

                    Player attackerPlayer = Player.Get(p);
                    if (attackerPlayer == null) continue;

                    string expGainedMessage2 = LevelUp.Instance.Translation.EventHintTrans.SCPDamageTip
                        .Replace("{exp}", exp.ToString())
                        .Replace("{roleColor}", attackerPlayer.RoleBase.RoleColor.ToHex())
                        .Replace("{damagepercent}", damagePercent.ToString("F1"))
                        .Replace("{SCP}", ev.Player.RoleBase.RoleName);

                    attackerPlayer.SendHint(expGainedMessage2, LevelUp.Instance.Config.showTime.gotexp);

                    LevelUp.Instance.CheckForLevelUp(attackerPlayer, playerData);
                }
            }
        }

        scpdamage.Remove(ev.Player.UserId);

        // Phase 3.1: 辅助击杀奖励
        if (playerDamageDealt.TryGetValue(ev.Player.UserId, out var attackers))
        {
            foreach (var assisterId in attackers)
            {
                // 跳过最后一击者（已经获得击杀经验）
                if (assisterId == ev.Attacker.UserId) continue;

                Player assister = Player.Get(assisterId);
                if (assister == null || assister.IsNpc) continue;

                if (!LevelUp.Instance.PlayerDataCache.TryGetValue(assisterId, out var assisterData))
                {
                    assisterData = new DataTemplates { UserId = assisterId };
                    LevelUp.Instance.PlayerDataCache[assisterId] = assisterData;
                }

                int assistExp = LevelUp.Instance.Config.expAmount.AssistKill;
                assisterData.Experience += assistExp;

                assister.SendHint($"<color={assister.RoleBase.RoleColor.ToHex()}>辅助击杀，获得经验</color><color=white>{assistExp}</color>",
                    LevelUp.Instance.Config.showTime.gotexp);

                if (LevelUp.Instance.Config.Debug)
                    Logger.Debug($"玩家 {assister.Nickname} 辅助击杀 {ev.Player.Nickname}，获得 {assistExp} 经验");

                LevelUp.Instance.CheckForLevelUp(assister, assisterData);
            }

            playerDamageDealt.Remove(ev.Player.UserId);
        }

        // Phase 3.1: 连杀奖励
        if (!playerKillTimes.ContainsKey(killerId))
            playerKillTimes[killerId] = new List<DateTime>();

        DateTime now = DateTime.Now;
        playerKillTimes[killerId].Add(now);

        // 移除超过时间窗口的击杀记录
        int windowSeconds = LevelUp.Instance.Config.expAmount.MultiKillWindow;
        playerKillTimes[killerId].RemoveAll(t => (now - t).TotalSeconds > windowSeconds);

        int killCount = playerKillTimes[killerId].Count;

        // Phase 4: 更新最高连杀记录
        if (killCount > killerData.HighestKillStreak)
        {
            killerData.HighestKillStreak = killCount;
            if (LevelUp.Instance.Config.Debug)
                Logger.Debug($"玩家 {ev.Attacker.Nickname} 创造新的连杀记录: {killCount}");
        }

        int multiKillExp = 0;
        string multiKillMsg = "";

        if (killCount == 2)
        {
            multiKillExp = LevelUp.Instance.Config.expAmount.DoubleKill;
            multiKillMsg = "双杀！";
        }
        else if (killCount == 3)
        {
            multiKillExp = LevelUp.Instance.Config.expAmount.TripleKill;
            multiKillMsg = "三连杀！";
        }
        else if (killCount == 4)
        {
            multiKillExp = LevelUp.Instance.Config.expAmount.QuadKill;
            multiKillMsg = "四连杀！";
        }
        else if (killCount >= 5)
        {
            multiKillExp = LevelUp.Instance.Config.expAmount.PentaKill;
            multiKillMsg = "五连杀！";
        }

        if (multiKillExp > 0)
        {
            killerData.Experience += multiKillExp;
            ev.Attacker.SendHint($"<color={ev.Attacker.RoleBase.RoleColor.ToHex()}>🔥{multiKillMsg} 获得经验</color><color=white>{multiKillExp}</color>",
                LevelUp.Instance.Config.showTime.gotexp);

            if (LevelUp.Instance.Config.Debug)
                Logger.Debug($"玩家 {ev.Attacker.Nickname} {multiKillMsg}，获得 {multiKillExp} 额外经验");
        }

        // Phase 3.4: 首杀奖励
        if (!playerKilledRoles.ContainsKey(killerId))
            playerKilledRoles[killerId] = new HashSet<RoleTypeId>();

        if (!playerKilledRoles[killerId].Contains(ev.Player.Role))
        {
            playerKilledRoles[killerId].Add(ev.Player.Role);
            int firstKillBonus = LevelUp.Instance.Config.expAmount.FirstKillBonus;
            killerData.Experience += firstKillBonus;

            ev.Attacker.SendHint($"<color={ev.Attacker.RoleBase.RoleColor.ToHex()}>首次击杀 {ev.Player.RoleBase.RoleName}，获得经验</color><color=white>{firstKillBonus}</color>",
                LevelUp.Instance.Config.showTime.gotexp);

            if (LevelUp.Instance.Config.Debug)
                Logger.Debug($"玩家 {ev.Attacker.Nickname} 首次击杀 {ev.Player.RoleBase.RoleName}，获得 {firstKillBonus} 额外经验");
        }

        // 检查是否升级
        LevelUp.Instance.CheckForLevelUp(ev.Attacker, killerData);
        }
        catch (System.Exception ex)
        {
            Logger.Error($"[Phase 6] OnPlayerDeath 处理异常: {ex.Message}");
            if (LevelUp.Instance.Config.Debug)
                Logger.Error($"堆栈跟踪: {ex.StackTrace}");
        }
    }

    /// <summary>
    /// 处理SCP玩家受到伤害
    /// </summary>
    /// <param name="ev"></param>
    public void OnPlayerHurt(PlayerHurtEventArgs ev)
    {
        try
        {
            if (ev.Attacker == ev.Player || ev.Player == null || ev.Attacker == null) return;

            // Phase 3.1: 追踪所有玩家对玩家的伤害（用于辅助击杀）
            if (!ev.Player.IsNpc && !ev.Attacker.IsNpc)
            {
                if (!playerDamageDealt.ContainsKey(ev.Player.UserId))
                    playerDamageDealt[ev.Player.UserId] = new HashSet<string>();

                playerDamageDealt[ev.Player.UserId].Add(ev.Attacker.UserId);
            }

            // SCP伤害追踪（原有逻辑）
            if (!ev.Player.IsSCP || ev.Player.Role == RoleTypeId.Scp0492 || ev.Player.IsNpc)
                return;

        // 确保SCP的伤害记录存在
        if(!scpdamage.ContainsKey(ev.Player.UserId))
            scpdamage.Add(ev.Player.UserId, new SCPDamageLog());

        SCPDamageLog damageLog = scpdamage[ev.Player.UserId];

        // 将攻击者添加到列表
        if(!damageLog.Attackers.Contains(ev.Attacker.UserId))
            damageLog.Attackers.Add(ev.Attacker.UserId);

        // 获取已有伤害值（如果不存在则为0）
        float previousDamage = damageLog.DamagePercent.TryGetValue(ev.Attacker.UserId, out float prevPercent)
            ? (prevPercent / 100f) * (ev.Player.MaxHealth + ev.Player.MaxHumeShield)
            : 0f;

        // 累加当前伤害
        // 从DamageHandler中获取伤害值
        float currentDamage = 0f;
        if (ev.DamageHandler is StandardDamageHandler standardHandler)
        {
            currentDamage = standardHandler.Damage;
        }
        else if (ev.DamageHandler is AttackerDamageHandler attackerHandler)
        {
            currentDamage = attackerHandler.Damage;
        }

        float totalDamage = currentDamage + previousDamage;

        // 更新伤害百分比
        damageLog.DamagePercent[ev.Attacker.UserId] = totalDamage / (ev.Player.MaxHealth + ev.Player.MaxHumeShield) * 100f;
        }
        catch (System.Exception ex)
        {
            Logger.Error($"[Phase 6] OnPlayerHurt 处理异常: {ex.Message}");
            if (LevelUp.Instance.Config.Debug)
                Logger.Error($"堆栈跟踪: {ex.StackTrace}");
        }
    }

    public void OnPlayerEscaped(PlayerEscapedEventArgs ev)
    {
        int exp = LevelUp.Instance.Config.expAmount.EscapedFacility;
        string expGainedMessage = LevelUp.Instance.Translation.EventHintTrans.EscapedFacility.
            Replace("{exp}", exp.ToString()).
            Replace("{roleColor}", ev.Player.RoleBase.RoleColor.ToHex());

        ev.Player.SendHint(expGainedMessage, LevelUp.Instance.Config.showTime.gotexp);

        if (!LevelUp.Instance.PlayerDataCache.TryGetValue(ev.Player.UserId, out var playerData))
        {
            playerData = new DataTemplates { UserId = ev.Player.UserId };
            LevelUp.Instance.PlayerDataCache[ev.Player.UserId] = playerData;
            if(LevelUp.Instance.Config.Debug)
                Logger.Debug($"玩家 {ev.Player.Nickname} 脱逃，创建玩家数据。");
        }
        if(LevelUp.Instance.Config.Debug)
            Logger.Debug($"玩家 {ev.Player.Nickname} 脱逃，获得 {exp} 经验。");

        LevelUp.Instance.PlayerDataCache[ev.Player.UserId].Experience += exp;
        LevelUp.Instance.CheckForLevelUp(ev.Player, LevelUp.Instance.PlayerDataCache[ev.Player.UserId]);
    }

    /// <summary>
    /// Phase 3.2: 拘留D级人员事件
    /// </summary>
    public void OnPlayerCuffing(PlayerCuffingEventArgs ev)
    {
        if (ev.Player == null || ev.Target == null || ev.Player.IsNpc || ev.Target.IsNpc)
            return;

        // 只有设施警卫拘留D级才给经验
        if (ev.Player.Role != RoleTypeId.FacilityGuard || ev.Target.Role != RoleTypeId.ClassD)
            return;

        if (!LevelUp.Instance.PlayerDataCache.TryGetValue(ev.Player.UserId, out var playerData))
        {
            playerData = new DataTemplates { UserId = ev.Player.UserId };
            LevelUp.Instance.PlayerDataCache[ev.Player.UserId] = playerData;
        }

        int exp = LevelUp.Instance.Config.expAmount.CuffDClass;
        playerData.Experience += exp;

        ev.Player.SendHint($"<color={ev.Player.RoleBase.RoleColor.ToHex()}>拘留D级人员，获得经验</color><color=white>{exp}</color>",
            LevelUp.Instance.Config.showTime.gotexp);

        if (LevelUp.Instance.Config.Debug)
            Logger.Debug($"玩家 {ev.Player.Nickname} 拘留D级 {ev.Target.Nickname}，获得 {exp} 经验");

        LevelUp.Instance.CheckForLevelUp(ev.Player, playerData);
    }

    /// <summary>
    /// Phase 3.2: 解除手铐事件
    /// </summary>
    public void OnPlayerUncuffed(PlayerUncuffedEventArgs ev)
    {
        if (ev.Player == null || ev.Target == null || ev.Player.IsNpc || ev.Target.IsNpc)
            return;

        // 自己解锁不给经验，互助才给
        if (ev.Player.UserId == ev.Target.UserId)
            return;

        if (!LevelUp.Instance.PlayerDataCache.TryGetValue(ev.Player.UserId, out var playerData))
        {
            playerData = new DataTemplates { UserId = ev.Player.UserId };
            LevelUp.Instance.PlayerDataCache[ev.Player.UserId] = playerData;
        }

        int exp = LevelUp.Instance.Config.expAmount.FreeCuffed;
        playerData.Experience += exp;

        ev.Player.SendHint($"<color={ev.Player.RoleBase.RoleColor.ToHex()}>解除队友手铐，获得经验</color><color=white>{exp}</color>",
            LevelUp.Instance.Config.showTime.gotexp);

        if (LevelUp.Instance.Config.Debug)
            Logger.Debug($"玩家 {ev.Player.Nickname} 解除 {ev.Target.Nickname} 的手铐，获得 {exp} 经验");

        LevelUp.Instance.CheckForLevelUp(ev.Player, playerData);
    }

    /// <summary>
    /// Phase 3.3: SCP击杀人类差异化
    /// </summary>
    private void ProcessScpKill(Player scp, Player victim, DataTemplates scpData)
    {
        int exp = LevelUp.Instance.Config.expAmount.ScpKillHuman;
        scpData.Experience += exp;

        scp.SendHint($"<color={scp.RoleBase.RoleColor.ToHex()}>击杀人类，获得经验</color><color=white>{exp}</color>",
            LevelUp.Instance.Config.showTime.gotexp);

        if (LevelUp.Instance.Config.Debug)
            Logger.Debug($"SCP {scp.Nickname} 击杀 {victim.Nickname}，获得 {exp} 经验");

        LevelUp.Instance.CheckForLevelUp(scp, scpData);
    }

    /// <summary>
    /// Phase 3.4: 存活时间奖励协程
    /// </summary>
    private IEnumerator<float> SurvivalRewardCoroutine()
    {
        int interval = LevelUp.Instance.Config.expAmount.SurvivalInterval;
        int reward = LevelUp.Instance.Config.expAmount.SurvivalReward;

        while (true)
        {
            yield return Timing.WaitForSeconds(interval);

            if (roundhasnotstarted) yield break;

            foreach (Player player in Player.List.ToList())
            {
                if (player == null || player.IsNpc || !player.IsAlive) continue;

                if (!LevelUp.Instance.PlayerDataCache.TryGetValue(player.UserId, out var playerData))
                {
                    playerData = new DataTemplates { UserId = player.UserId };
                    LevelUp.Instance.PlayerDataCache[player.UserId] = playerData;
                }

                playerData.Experience += reward;

                player.SendHint($"<color={player.RoleBase.RoleColor.ToHex()}>存活奖励，获得经验</color><color=white>{reward}</color>",
                    LevelUp.Instance.Config.showTime.gotexp);

                if (LevelUp.Instance.Config.Debug)
                    Logger.Debug($"玩家 {player.Nickname} 存活 {interval} 秒，获得 {reward} 经验");

                LevelUp.Instance.CheckForLevelUp(player, playerData);
            }
        }
    }

    public void RegisterAllEvents()
    {
        LabApi.Events.Handlers.PlayerEvents.ActivatingGenerator += OnPlayerActivatingGenerator;
        LabApi.Events.Handlers.PlayerEvents.Left += OnPlayerLeft;
        LabApi.Events.Handlers.PlayerEvents.Joined += OnPlayerJoined;
        LabApi.Events.Handlers.PlayerEvents.Death += OnPlayerDeath;
        LabApi.Events.Handlers.ServerEvents.RoundStarted += OnServerRoundStarted;
        LabApi.Events.Handlers.ServerEvents.RoundEnded += OnServerRoundEnded;
        LabApi.Events.Handlers.PlayerEvents.Hurt += OnPlayerHurt;
        LabApi.Events.Handlers.PlayerEvents.Escaped += OnPlayerEscaped;

        // Phase 3.2: 团队协作事件
        LabApi.Events.Handlers.PlayerEvents.Cuffing += OnPlayerCuffing;
        LabApi.Events.Handlers.PlayerEvents.Uncuffed += OnPlayerUncuffed;
    }

    public void UnregiserAllEvents()
    {
        LabApi.Events.Handlers.PlayerEvents.ActivatingGenerator -= OnPlayerActivatingGenerator;
        LabApi.Events.Handlers.PlayerEvents.Left -= OnPlayerLeft;
        LabApi.Events.Handlers.PlayerEvents.Joined -= OnPlayerJoined;
        LabApi.Events.Handlers.PlayerEvents.Death -= OnPlayerDeath;
        LabApi.Events.Handlers.ServerEvents.RoundStarted -= OnServerRoundStarted;
        LabApi.Events.Handlers.ServerEvents.RoundEnded -= OnServerRoundEnded;
        LabApi.Events.Handlers.PlayerEvents.Hurt -= OnPlayerHurt;
        LabApi.Events.Handlers.PlayerEvents.Escaped -= OnPlayerEscaped;

        // Phase 3.2: 团队协作事件
        LabApi.Events.Handlers.PlayerEvents.Cuffing -= OnPlayerCuffing;
        LabApi.Events.Handlers.PlayerEvents.Uncuffed -= OnPlayerUncuffed;
    }
}