Unityで実績（Achievement）システムを作る方法｜条件管理・セーブ・UI表示まで完全解説

public enum AchievementConditionType
{
    EnemyKillCount,
    ClearCount,
    GameOverCount,
    // 必要になったら増やす
}

using UnityEngine;

[CreateAssetMenu(menuName = "Achievements/Achievement Data")]
public class AchievementData : ScriptableObject
{
    [Header("Basic")]
    public string id;
    public string title;
    [TextArea] public string description;

    [Header("Visual")]
    public Sprite lockedIcon;
    public Sprite unlockedIcon;

    [Header("Condition")]
    public AchievementConditionType conditionType;
    public int targetValue = 1;
}

[System.Serializable]
public class AchievementState
{
    public string id;
    public int currentValue;
    public bool unlocked;

    public AchievementState(string id)
    {
        this.id = id;
        currentValue = 0;
        unlocked = false;
    }
}

using System;
using System.Collections.Generic;
using UnityEngine;

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

    [Header("Definitions")]
    [SerializeField] private List<AchievementData> achievementDefinitions;

    private Dictionary<string, AchievementState> states = new();
    private Dictionary<AchievementConditionType, int> stats = new();

    public event Action<AchievementData> OnUnlocked;

    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
        DontDestroyOnLoad(gameObject);

        InitializeStates();
        InitializeStats();
    }

    private void InitializeStates()
    {
        states.Clear();
        foreach (var def in achievementDefinitions)
        {
            if (def == null || string.IsNullOrEmpty(def.id)) continue;
            states[def.id] = new AchievementState(def.id);
        }
    }

    private void InitializeStats()
    {
        stats.Clear();
        foreach (AchievementConditionType type in Enum.GetValues(typeof(AchievementConditionType)))
        {
            stats[type] = 0;
        }
    }

    public IReadOnlyList<AchievementData> GetDefinitions() => achievementDefinitions;

    public AchievementState GetState(string id)
    {
        states.TryGetValue(id, out var state);
        return state;
    }
}

public void AddProgress(AchievementConditionType type, int amount)
{
    if (!stats.ContainsKey(type)) stats[type] = 0;

    stats[type] += amount;

    // この条件タイプに紐づく実績だけチェックする
    foreach (var def in achievementDefinitions)
    {
        if (def == null) continue;
        if (def.conditionType != type) continue;

        if (!states.TryGetValue(def.id, out var state)) continue;
        if (state.unlocked) continue;

        // 今回は「統計 = 進捗」として扱う（シンプル）
        state.currentValue = stats[type];

        if (state.currentValue >= def.targetValue)
        {
            Unlock(def);
        }
    }
}

private void Unlock(AchievementData def)
{
    if (!states.TryGetValue(def.id, out var state)) return;
    if (state.unlocked) return;

    state.unlocked = true;

    // 通知/UI側に知らせる
    OnUnlocked?.Invoke(def);

    // ※保存は次の章で実装（ここで呼ぶ想定）
}

private void Awake()
{
    if (Instance != null && Instance != this)
    {
        Destroy(gameObject);
        return;
    }
    Instance = this;
    DontDestroyOnLoad(gameObject);

    InitializeStates();
    InitializeStats();

    Load(); // ★ここで復元
}

public void Load()
{
    foreach (var def in achievementDefinitions)
    {
        if (def == null || string.IsNullOrEmpty(def.id)) continue;
        if (!states.TryGetValue(def.id, out var state)) continue;

        int unlockedInt = PlayerPrefs.GetInt(UnlockKey(def.id), 0);
        int valueInt = PlayerPrefs.GetInt(ValueKey(def.id), 0);

        state.unlocked = unlockedInt == 1;
        state.currentValue = valueInt;

        // 進捗の基準として stats も合わせて復元しておく（シンプル構成）
        if (!stats.ContainsKey(def.conditionType)) stats[def.conditionType] = 0;
        stats[def.conditionType] = Mathf.Max(stats[def.conditionType], state.currentValue);
    }
}

private void Unlock(AchievementData def)
{
    if (!states.TryGetValue(def.id, out var state)) return;
    if (state.unlocked) return;

    state.unlocked = true;

    OnUnlocked?.Invoke(def);

    SaveOne(def.id); // ★解除したら保存
}

public void SaveOne(string id)
{
    if (!states.TryGetValue(id, out var state)) return;

    PlayerPrefs.SetInt(UnlockKey(id), state.unlocked ? 1 : 0);
    PlayerPrefs.SetInt(ValueKey(id), state.currentValue);

    PlayerPrefs.Save();
}

public void ResetAllForDebug()
{
    PlayerPrefs.DeleteAll();
    PlayerPrefs.Save();

    InitializeStates();
    InitializeStats();
}

using UnityEngine;
using UnityEngine.UI;

public class AchievementCell : MonoBehaviour
{
    [Header("UI")]
    [SerializeField] private Image iconImage;
    [SerializeField] private Text titleText;
    [SerializeField] private Text descriptionText;
    [SerializeField] private Text progressText;
    [SerializeField] private GameObject lockedOverlay; // 任意

    private string achievementId;

    public void Setup(AchievementData def, AchievementState state)
    {
        achievementId = def.id;

        titleText.text = def.title;
        descriptionText.text = def.description;

        bool unlocked = state != null && state.unlocked;

        // アイコン切り替え（未解除/解除）
        iconImage.sprite = unlocked ? def.unlockedIcon : def.lockedIcon;

        // 進捗表示
        int current = state != null ? state.currentValue : 0;
        progressText.text = unlocked
            ? "Unlocked!"
            : $"{Mathf.Clamp(current, 0, def.targetValue)} / {def.targetValue}";

        // 未解除を暗くするなど（任意）
        if (lockedOverlay != null)
            lockedOverlay.SetActive(!unlocked);
    }
}

using System.Collections.Generic;
using UnityEngine;

public class AchievementsUI : MonoBehaviour
{
    [Header("UI References")]
    [SerializeField] private Transform contentParent;
    [SerializeField] private AchievementCell cellPrefab;

    private readonly List<AchievementCell> spawnedCells = new();

    private void OnEnable()
    {
        if (AchievementSystem.Instance != null)
        {
            AchievementSystem.Instance.OnUnlocked += HandleUnlocked;
        }

        RebuildList();
    }

    private void OnDisable()
    {
        if (AchievementSystem.Instance != null)
        {
            AchievementSystem.Instance.OnUnlocked -= HandleUnlocked;
        }
    }

    public void RebuildList()
    {
        // 既存セルを削除
        foreach (var cell in spawnedCells)
        {
            if (cell != null) Destroy(cell.gameObject);
        }
        spawnedCells.Clear();

        var defs = AchievementSystem.Instance.GetDefinitions();
        foreach (var def in defs)
        {
            var state = AchievementSystem.Instance.GetState(def.id);

            var cell = Instantiate(cellPrefab, contentParent);
            cell.Setup(def, state);

            spawnedCells.Add(cell);
        }
    }

    private void HandleUnlocked(AchievementData def)
    {
        // 解除されたら一覧を更新
        // （軽量化したいなら「該当セルだけ更新」に変更OK）
        RebuildList();
    }
}

public enum AchievementFilter
{
    All,
    LockedOnly,
    UnlockedOnly
}

[SerializeField] private AchievementFilter filter = AchievementFilter.All;

public void SetFilter(int filterIndex)
{
    filter = (AchievementFilter)filterIndex;
    RebuildList();
}

// RebuildListのforeach内で
var state = AchievementSystem.Instance.GetState(def.id);
bool unlocked = state != null && state.unlocked;

if (filter == AchievementFilter.LockedOnly && unlocked) continue;
if (filter == AchievementFilter.UnlockedOnly && !unlocked) continue;

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class AchievementsNotification : MonoBehaviour
{
    [Header("UI")]
    [SerializeField] private RectTransform panel;
    [SerializeField] private Text titleText;
    [SerializeField] private Text messageText;
    [SerializeField] private Image iconImage;

    [Header("Motion")]
    [SerializeField] private Vector2 hiddenPos = new Vector2(-800f, 0f);
    [SerializeField] private Vector2 shownPos  = new Vector2(40f, 0f);
    [SerializeField] private float slideDuration = 0.25f;
    [SerializeField] private float staySeconds = 2.0f;

    private readonly Queue<AchievementData> queue = new();
    private Coroutine playRoutine;

    private void Awake()
    {
        if (panel != null)
        {
            panel.anchoredPosition = hiddenPos;
        }
    }

    private void OnEnable()
    {
        if (AchievementSystem.Instance != null)
        {
            AchievementSystem.Instance.OnUnlocked += Enqueue;
        }
    }

    private void OnDisable()
    {
        if (AchievementSystem.Instance != null)
        {
            AchievementSystem.Instance.OnUnlocked -= Enqueue;
        }
    }

    private void Enqueue(AchievementData def)
    {
        if (def == null) return;

        queue.Enqueue(def);

        if (playRoutine == null)
        {
            playRoutine = StartCoroutine(PlayQueue());
        }
    }

    private IEnumerator PlayQueue()
    {
        while (queue.Count > 0)
        {
            var def = queue.Dequeue();
            SetupUI(def);

            // 出現
            yield return Slide(panel, hiddenPos, shownPos, slideDuration);

            // 滞在
            yield return new WaitForSeconds(staySeconds);

            // 退場
            yield return Slide(panel, shownPos, hiddenPos, slideDuration);

            // 連続解除が多いとき、少し間を空けると見やすい（任意）
            yield return new WaitForSeconds(0.05f);
        }

        playRoutine = null;
    }

    private void SetupUI(AchievementData def)
    {
        if (titleText != null) titleText.text = def.title;
        if (messageText != null) messageText.text = "Achievement Unlocked!";
        if (iconImage != null) iconImage.sprite = def.unlockedIcon != null ? def.unlockedIcon : def.lockedIcon;
    }

    private IEnumerator Slide(RectTransform rt, Vector2 from, Vector2 to, float duration)
    {
        if (rt == null) yield break;

        float t = 0f;
        rt.anchoredPosition = from;

        while (t < duration)
        {
            t += Time.unscaledDeltaTime; // UIは一時停止中も動かしたいことが多いので unscaled
            float p = Mathf.Clamp01(t / duration);

            // ちょいイージング（直線より気持ちいい）
            float eased = 1f - Mathf.Pow(1f - p, 3f);

            rt.anchoredPosition = Vector2.LerpUnclamped(from, to, eased);
            yield return null;
        }

        rt.anchoredPosition = to;
    }
}