public class AchievementSystem {
    public void UnlockAchievement(string achievementId) {
        var achievement = GetAchievement(achievementId);
        
        if (achievement.unlocked) {
            return; // 已解锁
        }
        
        // 标记为已解锁
        achievement.unlocked = true;
        achievement.unlockTimestamp = DateTime.UtcNow;
        
        // 保存进度
        SaveAchievementProgress();
        
        // 显示通知
        ShowUnlockNotification(achievement);
        
        // 播放音效
        AudioManager.Play("achievement_unlock");
        
        // 同步到平台（Steam、PlayStation 等）
        SyncToPlatform(achievementId);
        
        // 触发事件
        OnAchievementUnlocked?.Invoke(achievement);
    }
    
    private void ShowUnlockNotification(Achievement achievement) {
        var notification = new AchievementNotificationUI();
        notification.Show(achievement.name, achievement.description, achievement.icon);
        
        // 3 秒后自动隐藏
        StartCoroutine(HideNotificationAfter(notification, 3f));
    }
}

public class DelayedAchievementSystem {
    private List<string> pendingAchievements = new List<string>();
    
    public void QueueAchievement(string achievementId) {
        if (!pendingAchievements.Contains(achievementId)) {
            pendingAchievements.Add(achievementId);
        }
    }
    
    public void FlushPendingAchievements() {
        foreach (var achievementId in pendingAchievements) {
            UnlockAchievement(achievementId);
        }
        pendingAchievements.Clear();
    }
    
    // 在关卡结束时调用
    public void OnLevelComplete() {
        FlushPendingAchievements();
        ShowLevelCompleteScreen();
    }
}

public class CumulativeAchievement {
    public string id;
    public string name;
    public string description;
    public int targetValue;
    public int currentValue;
    public bool unlocked;
    
    public void AddProgress(int amount) {
        if (unlocked) return;
        
        currentValue += amount;
        
        if (currentValue >= targetValue) {
            currentValue = targetValue;
            Unlock();
        }
        
        // 更新 UI 进度条
        UpdateProgressBar();
    }
    
    private void Unlock() {
        unlocked = true;
        AchievementSystem.UnlockAchievement(id);
    }
    
    public float GetProgressPercentage() {
        return (float)currentValue / targetValue;
    }
}

// 使用示例
public class EnemyKillTracker {
    private CumulativeAchievement kill100Achievement = new CumulativeAchievement {
        id = "kill_100_enemies",
        name = "百人斩",
        description = "击败 100 个敌人",
        targetValue = 100,
        currentValue = 0
    };
    
    public void OnEnemyKilled() {
        kill100Achievement.AddProgress(1);
    }
}

public class AchievementNotificationUI : MonoBehaviour {
    public RectTransform panel;
    public Image icon;
    public Text titleText;
    public Text descriptionText;
    
    public void Show(string title, string description, Sprite iconSprite) {
        icon.sprite = iconSprite;
        titleText.text = title;
        descriptionText.text = description;
        
        // 滑入动画
        StartCoroutine(SlideInAnimation());
    }
    
    private IEnumerator SlideInAnimation() {
        var startPos = new Vector2(panel.anchoredPosition.x, -200);
        var endPos = new Vector2(panel.anchoredPosition.x, 100);
        
        panel.anchoredPosition = startPos;
        
        float duration = 0.5f;
        float elapsed = 0f;
        
        while (elapsed < duration) {
            elapsed += Time.deltaTime;
            var t = elapsed / duration;
            t = EaseOutCubic(t);
            
            panel.anchoredPosition = Vector2.Lerp(startPos, endPos, t);
            yield return null;
        }
        
        panel.anchoredPosition = endPos;
    }
    
    private float EaseOutCubic(float t) {
        return 1 - Mathf.Pow(1 - t, 3);
    }
}

using Steamworks;

public class SteamAchievementSystem {
    private static bool initialized = false;
    
    public static void Initialize() {
        if (!SteamManager.Initialized) {
            Debug.LogError("Steam is not initialized");
            return;
        }
        initialized = true;
    }
    
    public static void UnlockAchievement(string achievementId) {
        if (!initialized) {
            Initialize();
        }
        
        if (!initialized) {
            Debug.LogError("Steam is not initialized");
            return;
        }
        
        // 检查成就是否已解锁
        bool achieved = false;
        SteamUserStats.GetAchievement(achievementId, out achieved);
        
        if (achieved) {
            Debug.Log($"Achievement {achievementId} is already unlocked");
            return;
        }
        
        // 解锁成就
        bool success = SteamUserStats.SetAchievement(achievementId);
        
        if (success) {
            // 提交统计信息
            SteamUserStats.StoreStats();
            Debug.Log($"Achievement {achievementId} unlocked successfully");
        } else {
            Debug.LogError($"Failed to unlock achievement {achievementId}");
        }
    }
    
    public static bool IsAchievementUnlocked(string achievementId) {
        if (!initialized) {
            Initialize();
        }
        
        if (!initialized) {
            return false;
        }
        
        bool achieved = false;
        SteamUserStats.GetAchievement(achievementId, out achieved);
        return achieved;
    }
    
    public static float GetAchievementUnlockRate(string achievementId) {
        if (!initialized) {
            Initialize();
        }
        
        if (!initialized) {
            return 0f;
        }
        
        float percent = 0f;
        SteamUserStats.GetAchievementAchievedPercent(achievementId, out percent);
        return percent;
    }
}

// 使用示例
public class GameAchievementSystem : MonoBehaviour {
    private void Start() {
        SteamAchievementSystem.Initialize();
    }
    
    public void OnFirstEnemyKilled() {
        SteamAchievementSystem.UnlockAchievement("first_blood");
    }
    
    public void OnGameComplete() {
        SteamAchievementSystem.UnlockAchievement("game_complete");
    }
    
    public void OnAllItemsCollected() {
        SteamAchievementSystem.UnlockAchievement("perfect_collector");
    }
}

// PlayStation SDK 示例（伪代码）
using Sony.NP.Toolkit;

public class PlayStationTrophySystem {
    public static void UnlockTrophy(int trophyId) {
        var result = NpToolkit.UnlockTrophy(trophyId);
        
        if (result == NpToolkit.Result.Success) {
            Debug.Log($"Trophy {trophyId} unlocked successfully");
        } else {
            Debug.LogError($"Failed to unlock trophy {trophyId}: {result}");
        }
    }
    
    public static bool IsTrophyUnlocked(int trophyId) {
        var result = NpToolkit.GetTrophyUnlockState(trophyId);
        return result == NpToolkit.TrophyState.Unlocked;
    }
}

// 使用示例
public class GameTrophySystem : MonoBehaviour {
    public void OnFirstEnemyKilled() {
        PlayStationTrophySystem.UnlockTrophy(1); // 铜杯
    }
    
    public void OnGameComplete() {
        PlayStationTrophySystem.UnlockTrophy(10); // 金杯
    }
    
    public void OnAllTrophiesUnlocked() {
        // 白金奖杯自动解锁
    }
}

// Xbox Live SDK 示例（伪代码）
using Microsoft.Xbox.Services;
using Microsoft.Xbox.Services.System;
using Microsoft.Xbox.Services.Achievements;

public class XboxAchievementSystem {
    private XboxLiveContext xboxLiveContext;
    
    public void Initialize() {
        var xboxLiveUser = new XboxLiveUser();
        xboxLiveUser.SignInAsync();
        xboxLiveContext = new XboxLiveContext(xboxLiveUser);
    }
    
    public async void UnlockAchievement(string achievementId) {
        try {
            var achievementService = xboxLiveContext.AchievementService;
            await achievementService.UpdateAchievementAsync(achievementId, 100);
            Debug.Log($"Achievement {achievementId} unlocked successfully");
        } catch (Exception e) {
            Debug.LogError($"Failed to unlock achievement {achievementId}: {e.Message}");
        }
    }
}

// 使用示例
public class GameXboxAchievementSystem : MonoBehaviour {
    private void Start() {
        XboxAchievementSystem.Initialize();
    }
    
    public void OnFirstEnemyKilled() {
        XboxAchievementSystem.UnlockAchievement("first_blood");
    }
    
    public void OnGameComplete() {
        XboxAchievementSystem.UnlockAchievement("game_complete");
    }
}

[Serializable]
public class Achievement {
    public string id;
    public string name;
    public string description;
    public Sprite icon;
    public Sprite iconLocked; // 未解锁时的图标
    public bool hidden; // 是否隐藏成就
    public bool unlocked;
    public DateTime unlockTimestamp;
    
    // 累积成就
    public int targetValue;
    public int currentValue;
    
    // 平台特定 ID
    public string steamAchievementId;
    public int playstationTrophyId;
    public string xboxAchievementId;
    
    public float GetProgressPercentage() {
        if (targetValue == 0) return unlocked ? 100f : 0f;
        return (float)currentValue / targetValue * 100f;
    }
}

[Serializable]
public class AchievementProgress {
    public List<Achievement> achievements;
    public DateTime lastSaveTime;
    
    public int GetUnlockedCount() {
        return achievements.Count(a => a.unlocked);
    }
    
    public int GetTotalCount() {
        return achievements.Count;
    }
    
    public float GetOverallProgress() {
        return (float)GetUnlockedCount() / GetTotalCount() * 100f;
    }
}

public class AchievementStorage {
    private string savePath;
    
    public AchievementStorage() {
        savePath = Path.Combine(Application.persistentDataPath, "achievements.json");
    }
    
    public void Save(AchievementProgress progress) {
        var json = JsonUtility.ToJson(progress, true);
        File.WriteAllText(savePath, json);
    }
    
    public AchievementProgress Load() {
        if (!File.Exists(savePath)) {
            return CreateDefaultProgress();
        }
        
        var json = File.ReadAllText(savePath);
        return JsonUtility.FromJson<AchievementProgress>(json);
    }
    
    private AchievementProgress CreateDefaultProgress() {
        var progress = new AchievementProgress {
            achievements = new List<Achievement>(),
            lastSaveTime = DateTime.UtcNow
        };
        
        // 从配置文件加载成就定义
        var achievementDefinitions = Resources.Load<TextAsset>("AchievementDefinitions");
        var definitions = JsonUtility.FromJson<AchievementDefinitions>(achievementDefinitions.text);
        
        foreach (var def in definitions.achievements) {
            progress.achievements.Add(new Achievement {
                id = def.id,
                name = def.name,
                description = def.description,
                icon = Resources.Load<Sprite>($"Achievements/{def.id}"),
                iconLocked = Resources.Load<Sprite>("Achievements/locked"),
                hidden = def.hidden,
                unlocked = false,
                targetValue = def.targetValue,
                currentValue = 0,
                steamAchievementId = def.steamAchievementId,
                playstationTrophyId = def.playstationTrophyId,
                xboxAchievementId = def.xboxAchievementId
            });
        }
        
        return progress;
    }
}

public class AchievementListUI : MonoBehaviour {
    public Transform contentParent;
    public GameObject achievementItemPrefab;
    
    private AchievementProgress progress;
    
    public void Show() {
        progress = AchievementStorage.Load();
        
        // 清空现有列表
        foreach (Transform child in contentParent) {
            Destroy(child.gameObject);
        }
        
        // 创建成就项
        foreach (var achievement in progress.achievements) {
            var item = Instantiate(achievementItemPrefab, contentParent);
            var itemUI = item.GetComponent<AchievementItemUI>();
            itemUI.Setup(achievement);
        }
        
        // 更新进度统计
        UpdateProgressStats();
    }
    
    private void UpdateProgressStats() {
        var unlocked = progress.GetUnlockedCount();
        var total = progress.GetTotalCount();
        var percentage = progress.GetOverallProgress();
        
        progressText.text = $"进度：{unlocked}/{total} ({percentage:F1}%)";
        progressBar.value = percentage / 100f;
    }
}

public class AchievementItemUI : MonoBehaviour {
    public Image icon;
    public Text nameText;
    public Text descriptionText;
    public Text dateText;
    public GameObject progressBar;
    public Slider progressSlider;
    
    public void Setup(Achievement achievement) {
        icon.sprite = achievement.unlocked ? achievement.icon : achievement.iconLocked;
        
        if (achievement.hidden && !achievement.unlocked) {
            nameText.text = "???";
            descriptionText.text = "隐藏成就";
        } else {
            nameText.text = achievement.name;
            descriptionText.text = achievement.description;
        }
        
        if (achievement.unlocked) {
            dateText.text = achievement.unlockTimestamp.ToString("yyyy-MM-dd");
            dateText.gameObject.SetActive(true);
        } else {
            dateText.gameObject.SetActive(false);
        }
        
        if (achievement.targetValue > 0) {
            progressBar.SetActive(true);
            progressSlider.value = achievement.GetProgressPercentage() / 100f;
        } else {
            progressBar.SetActive(false);
        }
    }
}

{
    "achievements": [
        {
            "id": "first_blood",
            "name": "第一滴血",
            "description": "击败第一个敌人",
            "icon": "first_blood_icon",
            "hidden": false,
            "difficulty": "easy",
            "targetValue": 1,
            "steamAchievementId": "first_blood",
            "playstationTrophyId": 1,
            "xboxAchievementId": "first_blood",
            "gamerscore": 10,
            "trophyType": "bronze"
        },
        {
            "id": "game_complete",
            "name": "通关",
            "description": "完成游戏",
            "icon": "game_complete_icon",
            "hidden": false,
            "difficulty": "medium",
            "targetValue": 1,
            "steamAchievementId": "game_complete",
            "playstationTrophyId": 10,
            "xboxAchievementId": "game_complete",
            "gamerscore": 50,
            "trophyType": "gold"
        },
        {
            "id": "perfect_collector",
            "name": "完美收藏家",
            "description": "收集所有物品",
            "icon": "perfect_collector_icon",
            "hidden": false,
            "difficulty": "hard",
            "targetValue": 100,
            "steamAchievementId": "perfect_collector",
            "playstationTrophyId": 15,
            "xboxAchievementId": "perfect_collector",
            "gamerscore": 80,
            "trophyType": "gold"
        },
        {
            "id": "secret_ending",
            "name": "真结局",
            "description": "???",
            "icon": "secret_ending_icon",
            "hidden": true,
            "difficulty": "hard",
            "targetValue": 1,
            "steamAchievementId": "secret_ending",
            "playstationTrophyId": 20,
            "xboxAchievementId": "secret_ending",
            "gamerscore": 100,
            "trophyType": "gold"
        }
    ]
}