ターン制RPGの作り方#25｜セーブ・ロードとタイトル画面：遊んだ続きから始めよう

using System.Collections.Generic;

// セーブするもの。キャラクター・どうぐ・装備のアセットは、そのままでは保存できないので、アセットの名前で持つ
[System.Serializable]
public class SaveData
{
    public List<MemberSaveData> members = new List<MemberSaveData>(); // 仲間全員（並び順のまま。上の3人がバトルに出る）
    public List<ItemSaveData> items = new List<ItemSaveData>();       // 持ち物
    public List<string> equipments = new List<string>();              // 装備のふくろ
    public int gold;
    public int clearedFloorCount; // クリアした階の数
}

// 仲間1人分
[System.Serializable]
public class MemberSaveData
{
    public string character; // CharacterData の名前（Slime など）
    public int totalExp;
    public int hp;
    public int mp;
    public string weapon; // ぶきの名前（無ければ空）
    public string armor;  // ぼうぐの名前（無ければ空）
}

// どうぐ1種類と、その個数
[System.Serializable]
public class ItemSaveData
{
    public string item;
    public int count;
}

using System.IO;
using UnityEngine;

// セーブデータを JSON にして、ファイルに書く・読む
public static class SaveSystem
{
    // 保存する場所（Windows なら C:/Users/<ユーザー名>/AppData/LocalLow/<会社名>/<プロダクト名>）
    private static string SavePath => Path.Combine(Application.persistentDataPath, "save.json");

    // セーブのファイルがあるか（タイトルの「つづきから」を押せるか）
    public static bool HasSave => File.Exists(SavePath);

    public static void Save(SaveData data)
    {
        string json = JsonUtility.ToJson(data, true);
        File.WriteAllText(SavePath, json);
        Debug.Log($"セーブしました：{SavePath}");
    }

    // セーブを読む（無ければ null）
    public static SaveData Load()
    {
        if (!HasSave)
        {
            return null;
        }
        string json = File.ReadAllText(SavePath);
        return JsonUtility.FromJson<SaveData>(json);
    }
}

    // item を何個持っているか（持っていなければ 0）
    public int CountOf(ItemData item)
    {
        foreach (ItemStack stack in stacks)
        {
            if (stack.item == item)
            {
                return stack.count;
            }
        }
        return 0;
    }

    // 全部なくす（セーブから読むとき、最初の持ち物を消してから入れ直す）
    public void Clear()
    {
        stacks.Clear();
    }

    [SerializeField] private ItemData[] allItems;           // セーブから読むときに、名前で探す どうぐ（全部入れておく）
    [SerializeField] private EquipmentData[] allEquipments; // 同じく、装備（全部入れておく）

    // true にしてからロビーを読み込むと、セーブの続きから始める（タイトルの「つづきから」）
    public static bool LoadsSave { get; set; }

        // つづきから：最初の値を、セーブの中身で置きかえる
        if (LoadsSave)
        {
            LoadsSave = false; // 次に再生したときに、残らないように
            ApplySaveData(SaveSystem.Load());
        }

    // 今の仲間・持ち物・お金・進んだ階を、セーブデータにする
    public SaveData CreateSaveData()
    {
        SaveData data = new SaveData();
        foreach (PartyMember member in Members)
        {
            MemberSaveData memberData = new MemberSaveData();
            memberData.character = member.Data.name;
            memberData.totalExp = member.TotalExp;
            memberData.hp = member.Hp;
            memberData.mp = member.Mp;
            memberData.weapon = NameOf(member.Weapon);
            memberData.armor = NameOf(member.Armor);
            data.members.Add(memberData);
        }
        foreach (ItemData item in Inventory.Items())
        {
            ItemSaveData itemData = new ItemSaveData();
            itemData.item = item.name;
            itemData.count = Inventory.CountOf(item);
            data.items.Add(itemData);
        }
        foreach (EquipmentData equipment in Equipments)
        {
            data.equipments.Add(equipment.name);
        }
        data.gold = Gold;
        data.clearedFloorCount = ClearedFloorCount;
        return data;
    }

    // セーブデータの中身に置きかえる（名前から、アセットを探して戻す）
    private void ApplySaveData(SaveData data)
    {
        Members.Clear();
        foreach (MemberSaveData memberData in data.members)
        {
            CharacterData character = FindByName(startMembers, memberData.character);
            PartyMember member = new PartyMember(character, memberData.totalExp);
            member.Equip(EquipSlot.Weapon, FindByName(allEquipments, memberData.weapon));
            member.Equip(EquipSlot.Armor, FindByName(allEquipments, memberData.armor));
            // HP・MP は、装備を付けてから入れる（装備の分だけ、最大HP・MPが増えるので）
            member.Hp = memberData.hp;
            member.Mp = memberData.mp;
            Members.Add(member);
        }

        Inventory.Clear();
        foreach (ItemSaveData itemData in data.items)
        {
            Inventory.Add(FindByName(allItems, itemData.item), itemData.count);
        }
        Equipments.Clear();
        foreach (string equipmentName in data.equipments)
        {
            Equipments.Add(FindByName(allEquipments, equipmentName));
        }
        Gold = data.gold;
        ClearedFloorCount = data.clearedFloorCount;
    }

    // アセットの名前（無ければ空の文字）
    private static string NameOf(Object asset)
    {
        if (asset == null)
        {
            return "";
        }
        return asset.name;
    }

    // assets の中から、名前が assetName のものを探す（無ければ null）
    private static T FindByName<T>(T[] assets, string assetName) where T : Object
    {
        foreach (T asset in assets)
        {
            if (asset.name == assetName)
            {
                return asset;
            }
        }
        return null;
    }

    [SerializeField] private Button saveButton;       // セーブ

        partyButton.onClick.AddListener(OnPartyClicked);
        saveButton.onClick.AddListener(OnSaveClicked);

    private async void OnSaveClicked()
    {
        if (isBusy)
        {
            return;
        }
        isBusy = true;
        try
        {
            await SaveAsync();
        }
        catch (System.OperationCanceledException)
        {
            return;
        }
        isBusy = false;
    }

    // セーブ：3人が本に、ぼうけんの記録を書きこむ。そのあいだに、ファイルに保存する
    private async Awaitable SaveAsync()
    {
        GameSession session = GameSession.Instance;
        List<PartyMember> party = session.Party;
        List<Awaitable> writings = new List<Awaitable>();
        for (int i = 0; i < party.Count; i++)
        {
            if (!party[i].IsDead) // 倒れている人は、書かない
            {
                writings.Add(partyViews[i].PlayBookAsync());
            }
        }
        SaveSystem.Save(session.CreateSaveData());
        foreach (Awaitable writing in writings)
        {
            await writing;
        }
        await messageWindow.ShowAsync("ぼうけんの きろくを かきこんだ！");
        foreach (UnitView view in partyViews)
        {
            view.ResumeIdle();
        }
    }

{
    "members": [
        {
            "character": "Slime",
            "totalExp": 330,
            "hp": 83,
            "mp": 17,
            "weapon": "PaperKnife",
            "armor": ""
        },
        {
            "character": "Fairy",
            "totalExp": 300,
            "hp": 50,
            "mp": 44,
            "weapon": "",
            "armor": "BookCover"
        },
        {
            "character": "Jiangshi",
            "totalExp": 310,
            "hp": 61,
            "mp": 14,
            "weapon": "",
            "armor": ""
        },
        {
            "character": "Medusa",
            "totalExp": 280,
            "hp": 52,
            "mp": 42,
            "weapon": "",
            "armor": ""
        }
    ],
    "items": [
        {
            "item": "HerbTea",
            "count": 3
        },
        {
            "item": "MagicCookie",
            "count": 2
        },
        {
            "item": "AlarmClock",
            "count": 1
        }
    ],
    "equipments": [
        "MagicPen"
    ],
    "gold": 480,
    "clearedFloorCount": 2
}

using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

// タイトル：はじめから・つづきから。セーブが無ければ、つづきからは押せない（灰色）
public class TitleMenu : MonoBehaviour
{
    [SerializeField] private RectTransform logo;    // タイトルの文字（上から落ちてきて、ぽよんと弾む）
    [SerializeField] private CanvasGroup menuGroup; // ボタンのウインド（文字が落ちてから出す）
    [SerializeField] private Button newGameButton;  // はじめから
    [SerializeField] private Button continueButton; // つづきから
    [SerializeField] private SceneFader sceneFader;
    [SerializeField] private float dropSeconds = 0.5f;   // 落ちてくる時間
    [SerializeField] private float squashSeconds = 0.3f; // つぶれて戻る時間

    private bool isBusy; // ロビーへ切り替えている間は、ボタンを受け付けない

    private async void Start()
    {
        bool hasSave = SaveSystem.HasSave;
        continueButton.interactable = hasSave;
        newGameButton.onClick.AddListener(OnNewGameClicked);
        continueButton.onClick.AddListener(OnContinueClicked);

        menuGroup.alpha = 0f;
        menuGroup.interactable = false;
        try
        {
            await DropLogoAsync();
            await ShowMenuAsync();
        }
        catch (System.OperationCanceledException)
        {
            return;
        }
        // セーブがあれば「つづきから」、無ければ「はじめから」を選んでおく
        Button firstButton = hasSave ? continueButton : newGameButton;
        EventSystem.current.SetSelectedGameObject(firstButton.gameObject);
    }

    private void OnNewGameClicked()
    {
        StartGame(false);
    }

    private void OnContinueClicked()
    {
        StartGame(true);
    }

    // ロビーへ。loadsSave が true なら、セーブの続きから
    private async void StartGame(bool loadsSave)
    {
        if (isBusy)
        {
            return;
        }
        isBusy = true;
        GameSession.LoadsSave = loadsSave;
        try
        {
            await sceneFader.LoadSceneAsync("Lobby");
        }
        catch (System.OperationCanceledException)
        {
            // シーンが切り替わったら、そこで終わり
        }
    }

    // タイトルの文字が、上から落ちてきて、着地でつぶれてから戻る
    private async Awaitable DropLogoAsync()
    {
        Vector2 to = logo.anchoredPosition;
        Vector2 from = to + new Vector2(0f, 600f);
        float time = 0f;
        while (time < dropSeconds)
        {
            time += Time.deltaTime;
            float rate = Mathf.Clamp01(time / dropSeconds);
            logo.anchoredPosition = Vector2.Lerp(from, to, rate * rate); // だんだん速く落ちる
            await Awaitable.NextFrameAsync(destroyCancellationToken);
        }

        time = 0f;
        while (time < squashSeconds)
        {
            time += Time.deltaTime;
            // Sin で 0 → 1 → 0。いちばんつぶれたときに、横 1.15 倍・縦 0.8 倍
            float wave = Mathf.Sin(Mathf.Clamp01(time / squashSeconds) * Mathf.PI);
            logo.localScale = new Vector3(1f + 0.15f * wave, 1f - 0.2f * wave, 1f);
            await Awaitable.NextFrameAsync(destroyCancellationToken);
        }
        logo.localScale = Vector3.one;
    }

    // ボタンのウインドを、ふわっと出す
    private async Awaitable ShowMenuAsync()
    {
        const float seconds = 0.3f;
        float time = 0f;
        while (time < seconds)
        {
            time += Time.deltaTime;
            menuGroup.alpha = Mathf.Clamp01(time / seconds);
            await Awaitable.NextFrameAsync(destroyCancellationToken);
        }
        menuGroup.alpha = 1f;
        menuGroup.interactable = true;
    }
}