Unityのシリアライズ完全ガイド！データの保存・読み込みを自由自在に

1. はじめに

ゲームを作っていると、「プレイヤーのスコアを保存したい」「キャラクターのステータスを次のプレイ時にも保持したい」といった場面に必ず遭遇しますよね。そんなときに必要になるのが**「データの保存・読み込み」**です。でも、どうやってデータを保存すればいいのか、最初はよくわからないものです。

そこで登場するのが**「シリアライズ」という技術です！シリアライズを使えば、データをファイルに保存したり、JSONやバイナリ形式で扱ったりできるようになります。これをマスターすれば、セーブ機能の実装やゲーム設定の保存**が自由自在になりますよ。

この記事では、Unityにおけるシリアライズの基礎から実践的な活用方法まで、初心者でもわかりやすく解説します！JSON形式やバイナリ形式の違い、PlayerPrefs や ScriptableObject を活用したデータ管理など、幅広い内容を扱うので、ぜひ最後まで読んでみてくださいね！

2. シリアライズとは？

ゲーム開発をしていると、「データを保存する方法が知りたい！」と思うことがありますよね？プレイヤーの進行状況や設定情報を次回のプレイ時に復元するには、データを保存しておく必要があります。そのときに登場するのが 「シリアライズ（Serialize）」 という仕組みです。

シリアライズの基本概念

シリアライズとは、オブジェクトのデータを保存可能な形式に変換すること を指します。たとえば、ゲーム内でプレイヤーのスコアやキャラクターの位置などを保存したいとき、その情報を ファイルやデータベースに書き込める形に変換する 必要があります。この変換プロセスが「シリアライズ」です。

逆に、保存されたデータを元のオブジェクトに戻すことを「デシリアライズ（Deserialize）」と言います。

✅ シリアライズ： オブジェクト → 保存可能なデータ形式（JSON、バイナリなど）
✅ デシリアライズ： 保存されたデータ → オブジェクトに変換

Unityにおけるシリアライズの役割

Unityでは、ゲームオブジェクトやスクリプトのデータをシリアライズすることで、以下のような用途に活用できます。

• ゲームの設定情報を保存（BGMの音量、難易度設定など）
• プレイヤーの進行状況を記録（レベル、スコア、所持アイテムなど）
• シーン間でデータを引き継ぐ（キャラクターの状態、取得アイテムなど）
• エディターで値を保存・復元（インスペクターで変数を設定）

Unityでは、[SerializeField] を使うと インスペクター上で値を保持することが可能 になります。これはエディター上のシリアライズ機能を利用しており、ゲームを閉じても値がリセットされないようになっています。

一般的なシリアライズの種類

シリアライズされたデータは、さまざまな形式で保存できます。代表的な方法を3つ紹介します。

1. JSON（JavaScript Object Notation）
   • 可読性が高く、外部とのデータ連携に便利
   • Unityでは JsonUtility を使って簡単に扱える
2. バイナリ（Binary）
   • データサイズが小さく、読み書きが高速
   • 直接編集できないため、デバッグはやや難しい
3. XML（Extensible Markup Language）
   • 可読性はあるが、JSONより冗長なため使用頻度は低め
   • 特定のシステムとの連携時に使うことがある

Unityでは特に JSON や バイナリ を使うことが多いです。それぞれのメリット・デメリットについては、後の章で詳しく解説します。

シリアライズの仕組みを理解すれば、ゲームのデータを自由自在に保存・読み込み できるようになります。次のステップでは、Unityでのシリアライズの基本的な実装方法について詳しく解説していきます！

3. Unityでのシリアライズの基本

Unityでゲームを作っていると、「変数の値が保存されない！」「エディタで設定したのにスクリプトからアクセスできない…」といった経験はありませんか？ それ、もしかするとシリアライズが関係しているかもしれません。

このステップでは、Unityにおけるシリアライズの基本をわかりやすく解説します！

シリアライズとは？

シリアライズとは、オブジェクト（データ）を保存可能な形式に変換することです。
ゲームでは、キャラクターのステータスやプレイヤーの進行状況、設定データなどを保存・読み込みする必要がありますよね？
Unityでは、スクリプトのデータをシリアライズしてエディタ上で表示したり、データを保持したりすることができます。

Unityでは、主に次のようなシリアライズの方法があります：

• [SerializeField] を使う
• ScriptableObject を活用する
• PlayerPrefsを使う

では、それぞれ詳しく見ていきましょう！

① [SerializeField] を使って変数をエディタで表示

[SerializeField] を使うと、private 変数でもエディタ上に表示され、値を変更できるようになります。

たとえば、以下のようなスクリプトを見てください。

using UnityEngine;

public class Player : MonoBehaviour
{
    [SerializeField] // privateでもInspectorに表示される！
    private int hp = 100;

    private int score = 0; // Inspectorに表示されない
}

この場合、hp の値は Inspectorウィンドウで確認・編集 できますが、score は表示されません。
[SerializeField] を使うと、エディタで値を自由に調整しながら開発ができるので、デバッグやバランス調整に役立ちます！

② ScriptableObject を活用する

ScriptableObject は、データを保存・管理するための特殊なオブジェクトです。
例えば、敵のステータスやアイテムデータを管理するときに便利です。

ScriptableObject の作り方

1. プロジェクトウィンドウを右クリック
   「Create」→「C# Script」を選択し、EnemyData というスクリプトを作成します。
2. スクリプトを以下のように編集

using UnityEngine;

[CreateAssetMenu(fileName = "NewEnemyData", menuName = "Game Data/Enemy")]
public class EnemyData : ScriptableObject
{
    public string enemyName;
    public int hp;
    public int attackPower;
}

3. 新しいデータを作成
   プロジェクトウィンドウで「右クリック」→「Game Data」→「Enemy」を選択すると、新しいデータファイルを作成できます！
   ここに敵のステータス情報を保存しておくことで、スクリプトから簡単に参照できるようになります。

public class Enemy : MonoBehaviour
{
    public EnemyData enemyData;

    void Start()
    {
        Debug.Log("敵の名前：" + enemyData.enemyName);
        Debug.Log("HP：" + enemyData.hp);
    }
}

これで、敵ごとのデータを簡単に管理できるようになりました！

③ PlayerPrefsを使ってデータを保存

PlayerPrefs は、ゲームの設定やスコアなど、小規模なデータを保存するための仕組みです。
たとえば、音量設定や最終スコアを保存するのに適しています。

// スコアを保存
PlayerPrefs.SetInt("HighScore", 5000);
PlayerPrefs.Save();

// 保存したスコアを取得
int highScore = PlayerPrefs.GetInt("HighScore", 0); // 0はデフォルト値
Debug.Log("ハイスコア：" + highScore);

ただし、PlayerPrefsは大量のデータを保存するのには向いていないので、セーブデータとしては別の方法を使うのがオススメです。

まとめ

• [SerializeField] を使うと、private 変数でもエディタで設定可能！
• ScriptableObject を使うと、データを管理しやすくなる！
• PlayerPrefs は小規模な設定データの保存に便利！

Unityのデフォルトのシリアライズ機能では、SerializeField を使ってデータをインスペクターに表示できますが、制約もあります。より直感的にデータ管理を行いたいなら、Odin Inspector and Serializer を使うのがオススメです。このアセットを導入すると、シリアライズの設定が柔軟になり、カスタムエディターの作成も簡単になります。

これらのテクニックを活用すれば、データを柔軟に管理して、スムーズなゲーム開発が可能になります！
次のステップでは、JSONを使ったデータ保存・読み込みについて解説していきます！

4. JSONを使ったデータ保存・読み込み

Unityでデータを保存・読み込む方法はいくつかありますが、最もシンプルで扱いやすいのが**JSON（JavaScript Object Notation）**を使った方法です。JSONはテキスト形式なので、人間が読める形でデータを保存できるのが特徴です。

この記事では、JsonUtility を使ってデータをJSON形式で保存・読み込む方法を解説します！

JSONとは？

JSONは、データを構造化して保存できるフォーマットです。例えば、プレイヤーの名前やスコア、レベル情報などを次のように記述できます。

{
    "playerName": "Taro",
    "score": 1500,
    "level": 5
}

この形式なら、簡単にデータを保存し、後で読み込むことができます。

1. JSONを使うための準備

まず、UnityのJsonUtility を使うために、保存したいデータをクラスとして定義します。

データ用のクラスを作成

プロジェクトウィンドウを右クリックして「Create」→「C# Script」を選び、新しいスクリプトを作成し、「GameData」と名前を付けます。
次に、以下のようにスクリプトを編集します。

using UnityEngine;

[System.Serializable] // シリアライズ可能にする
public class GameData
{
    public string playerName;
    public int score;
    public int level;
}

[System.Serializable] を付けることで、このクラスのデータをJSON形式に変換できるようになります。

2. JSON形式でデータを保存する

次に、JSONを使ってデータを保存する処理を作成しましょう。

スクリプトを作成

「Create」→「C# Script」を選び、新しいスクリプトを作成し、「SaveLoadManager」と名前を付けます。

以下のコードを入力してください。

using UnityEngine;
using System.IO;

public class SaveLoadManager : MonoBehaviour
{
    private string filePath;

    void Start()
    {
        filePath = Application.persistentDataPath + "/gameData.json"; 
    }

    public void SaveGame()
    {
        GameData data = new GameData();
        data.playerName = "Taro";
        data.score = 2000;
        data.level = 3;

        string json = JsonUtility.ToJson(data, true);
        File.WriteAllText(filePath, json);
        
        Debug.Log("データを保存しました: " + json);
    }
}

コードのポイント

• JsonUtility.ToJson(data, true)
  → クラスのデータをJSON文字列に変換
• File.WriteAllText(filePath, json)
  → JSONデータをファイルに保存
• Application.persistentDataPath
  → アプリごとに安全な保存場所を確保（PCならC:\Users\ユーザー名\AppData\LocalLow\会社名\ゲーム名）

このスクリプトを空のGameObjectにアタッチし、Inspectorで「SaveGame()」を呼び出せば、JSONファイルが作成されます！

3. JSONデータを読み込む

保存したデータを再び読み込む処理も作ってみましょう。

先ほどのSaveLoadManagerに、以下のメソッドを追加してください。

public void LoadGame()
{
    if (File.Exists(filePath))
    {
        string json = File.ReadAllText(filePath);
        GameData data = JsonUtility.FromJson<GameData>(json);

        Debug.Log("データを読み込みました: ");
        Debug.Log("プレイヤー名: " + data.playerName);
        Debug.Log("スコア: " + data.score);
        Debug.Log("レベル: " + data.level);
    }
    else
    {
        Debug.Log("保存データが見つかりません。");
    }
}

コードのポイント

• File.Exists(filePath) でファイルがあるかチェック
• File.ReadAllText(filePath) でJSONデータを読み込む
• JsonUtility.FromJson<GameData>(json) でデータをクラスに変換

このメソッドを呼び出せば、保存されたJSONファイルを読み込んで、データを再利用できます。

4. ボタンでデータを保存・読み込み

ボタンを使ってデータを保存・読み込めるようにしてみましょう。

1. UnityのHierarchyウィンドウで「UI」→「Button」を作成
2. ボタンを選択し、Inspectorの「OnClick」にSaveLoadManagerのSaveGame()を設定
3. もう一つボタンを作り、LoadGame()を設定

これで、ボタンを押すだけでデータの保存・読み込みができるようになります！

まとめ

この記事では、JsonUtility を使ってJSON形式でデータを保存・読み込む方法を解説しました。

✅ ポイントのおさらい

• JsonUtility.ToJson() でデータをJSONに変換
• File.WriteAllText() でJSONをファイルに保存
• File.ReadAllText() でJSONを読み込む
• JsonUtility.FromJson<GameData>() でオブジェクトに復元

UnityにはJsonUtilityを使ったJSONシリアライズ機能がありますが、複雑なデータ構造や暗号化が必要な場合は手間が増えます。
特に、ゲームの進行状況やプレイヤーデータを管理する場合、より柔軟なシステムが必要です。

そこでオススメなのが Easy Save – The Complete Save & Load Asset です！

✅ コードをほぼ書かずにデータ保存が可能
✅ JSON形式だけでなくバイナリ形式にも対応
✅ 暗号化機能付きでセキュリティも安心！

「手軽にデータ保存・読み込みを実装したいなら、Easy Saveを導入するのが一番ラク！」 という人も多いので、ぜひチェックしてみてください。

シンプルな方法でデータを管理したいときに、ぜひJSONシリアライズを活用してください！

5. バイナリシリアライズを活用する

ゲームデータを保存するとき、JSONを使う方法が一般的ですが、データを軽量化したり、可読性を下げてセキュリティを向上させたりするにはバイナリシリアライズが役立ちます。バイナリデータはファイルサイズが小さく、読み書きの処理も高速です。
このステップでは、Unityでバイナリシリアライズを活用する方法を解説します！

バイナリシリアライズとは？

バイナリシリアライズとは、データをバイナリ形式（0と1のデータ列）に変換して保存する方法です。
バイナリデータは人間が直接読むのは難しいですが、その分、データサイズを抑え、処理を高速化できます。

例えば、以下のようなJSONデータ：

{
    "playerName": "Hero",
    "level": 5,
    "hp": 100
}

これをバイナリ化すると、意味不明なデータの塊になります。しかし、その分軽量かつ高速に扱えるようになります。

バイナリデータを保存する方法

Unityでは、BinaryFormatter を使ってオブジェクトをバイナリファイルとして保存できます。

1. 保存するデータ用のクラスを作成

まず、保存するデータ用のクラスを作りましょう。このクラスには [Serializable] を付けてシリアライズ可能にします。

using System;

[Serializable] // シリアライズ可能にする
public class PlayerData
{
    public string playerName;
    public int level;
    public float hp;
}

2. バイナリデータを保存するスクリプト

次に、この PlayerData をバイナリ形式で保存する処理を作ります。

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using UnityEngine;

public class SaveSystem
{
    public static void SavePlayer(PlayerData data)
    {
        BinaryFormatter formatter = new BinaryFormatter();
        string path = Application.persistentDataPath + "/player.dat"; // 保存パス
        FileStream stream = new FileStream(path, FileMode.Create);

        formatter.Serialize(stream, data); // バイナリ形式でシリアライズ
        stream.Close();
        Debug.Log("データを保存しました: " + path);
    }
}

このコードでは：

• BinaryFormatter を使って PlayerData をバイナリ化
• FileStream を作成し、Application.persistentDataPath に player.dat というファイルを保存
• stream.Close(); でファイルを閉じる

バイナリデータを読み込む方法

今度は、保存したバイナリデータを読み込む処理を作ります。

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using UnityEngine;

public class LoadSystem
{
    public static PlayerData LoadPlayer()
    {
        string path = Application.persistentDataPath + "/player.dat";
        if (File.Exists(path))
        {
            BinaryFormatter formatter = new BinaryFormatter();
            FileStream stream = new FileStream(path, FileMode.Open);

            PlayerData data = formatter.Deserialize(stream) as PlayerData; // バイナリをデシリアライズ
            stream.Close();
            Debug.Log("データをロードしました: " + path);
            return data;
        }
        else
        {
            Debug.LogError("セーブデータが見つかりません！");
            return null;
        }
    }
}

このコードでは：

• File.Exists(path) でデータが存在するか確認
• BinaryFormatter を使ってバイナリをデシリアライズし、PlayerData のオブジェクトに戻す
• stream.Close(); でファイルを閉じる

JSONとバイナリの比較

バイナリは「データ量を減らして高速化したい」場合に向いています。
逆に「人がデータを編集しやすくしたい」ならJSONの方が良いですね。

まとめ

• バイナリシリアライズは、データを軽量で高速に保存するのに便利！
• BinaryFormatter を使って、簡単にバイナリデータを保存・読み込みできる
• JSONとの使い分けを考えよう！可読性を重視するならJSON、効率を重視するならバイナリ。

Unity標準のBinaryFormatterを使えば、バイナリ形式でデータを保存できますが、
型の制限やバージョン管理の難しさがあり、初心者には少し扱いにくいのが難点です。

「もっと簡単に、しかもセキュリティを強化してバイナリ保存したい！」という方には、
Easy Save がピッタリです！

✔ 複雑なデータもワンクリックで保存
✔ バイナリとJSONの両方に対応
✔ クラウドへの保存機能も完備

「セーブ＆ロード機能を手軽に実装したいなら、迷わずEasy Save！」
バイナリでのデータ管理をより簡単にしたい人は、ぜひ導入を検討してみてください。

これで、Unityのデータ保存をさらに深く理解できましたね！
次はデータの暗号化やクラウド保存にも挑戦してみましょう！

6. ScriptableObjectを使ったデータ管理

Unityでゲームデータを管理するとき、スクリプト内に変数を持たせる方法もありますが、データを分離して管理できる ScriptableObject（スクリプタブルオブジェクト） を使うと便利です。これを活用すると、ゲーム内で使うデータを簡単に再利用・共有できる ようになります。

ScriptableObjectとは？

ScriptableObject とは、データを格納するための特殊なC#クラス です。通常のスクリプトと違い、GameObjectに依存せず、アセットとして保存できる という特長があります。

例えば、ゲーム内の設定データやアイテムのデータ、キャラクターのパラメータ などを管理するのに最適です。スクリプト内でデータを保持すると、シーンをまたいだときにデータが消えてしまうことがありますが、ScriptableObjectならデータが保持されます。

ScriptableObjectを作成してみよう！

それでは、実際に ScriptableObjectを使ったデータ管理 をしてみましょう！今回は 「キャラクターデータ」を管理するScriptableObject を作成します。

1. ScriptableObjectのC#スクリプトを作成

まずは、ScriptableObjectのC#スクリプト を作成します。

1. プロジェクトウィンドウ を右クリック
2. 「Create」 → 「C# Script」 を選択
3. スクリプト名を CharacterData に変更

スクリプトを開いて、次のコードを入力してください。

using UnityEngine;

[CreateAssetMenu(fileName = "NewCharacterData", menuName = "GameData/CharacterData")]
public class CharacterData : ScriptableObject
{
    public string characterName; // キャラクターの名前
    public int health;           // HP（体力）
    public int attackPower;      // 攻撃力
}

コードの解説

• [CreateAssetMenu]：このスクリプトを元に アセットを作成できるようにする 設定
  • fileName = "NewCharacterData" → 作成するデフォルトのファイル名
  • menuName = "GameData/CharacterData" → Unityエディタのメニューに表示される名前
• public string characterName; → キャラクターの名前
• public int health; → キャラクターのHP
• public int attackPower; → キャラクターの攻撃力

2. ScriptableObjectのアセットを作成

次に、ScriptableObjectのアセット を作成します。

1. プロジェクトウィンドウ を右クリック
2. 「Create」 → 「GameData」 → 「CharacterData」 を選択
3. 作成された 「NewCharacterData」 を選択し、名前を “WarriorData” に変更
4. インスペクターウィンドウ で次の値を設定
   • Character Name → Warrior（戦士）
   • Health → 100
   • Attack Power → 20

これで “WarriorData” というキャラクターのデータが保存されました！他のキャラを追加したい場合は、同じ手順で別のデータを作成できます。

3. ScriptableObjectをスクリプトで利用

作成した ScriptableObjectのデータ をスクリプトで読み込んでみましょう。

1. プロジェクトウィンドウ で 「Create」 → 「C# Script」 を選択し、スクリプト名を CharacterManager に変更
2. スクリプトを開いて、次のコードを入力

using UnityEngine;

public class CharacterManager : MonoBehaviour
{
    public CharacterData characterData;

    void Start()
    {
        Debug.Log("キャラクター名: " + characterData.characterName);
        Debug.Log("HP: " + characterData.health);
        Debug.Log("攻撃力: " + characterData.attackPower);
    }
}

4. Unityで設定

1. シーン内の適当なGameObjectを選択
2. 「CharacterManager」スクリプトをアタッチ
3. 「CharacterData」フィールドに作成した”WarriorData”をドラッグ＆ドロップ
4. ゲームを再生すると、コンソールに次のように表示されます。

キャラクター名: Warrior
HP: 100
攻撃力: 20

これで、ScriptableObjectを使ってキャラクターデータを管理できました！

ScriptableObjectのメリット

✅ データをアセットとして管理できる → スクリプトを変更しなくてもデータを調整可能
✅ 再利用が簡単 → 1つのScriptableObjectを複数のスクリプトで使える
✅ メモリ管理が最適化される → ゲームオブジェクトに依存しないため、無駄なメモリ消費を防げる

ScriptableObjectを使うと、データの管理がしやすくなりますが、インスペクターでの表示が見にくいこともあります。そんなときに便利なのが Odin Inspector and Serializer です。これを使えば、ScriptableObjectのデータを見やすくカスタマイズでき、開発の効率がぐっと上がります。

ScriptableObjectを使うと、ゲームデータをシンプルかつ効率的に管理 できます。
特に キャラクター、アイテム、ステージ情報、設定データ などの管理に便利です。
ぜひ活用して、よりスムーズなゲーム開発を目指しましょう！

7. PlayerPrefsを使ったデータ保存

Unityで手軽にデータを保存する方法のひとつに PlayerPrefs があります。
PlayerPrefsは、ゲームの設定やスコアなどの小さなデータを保存するのに適しており、簡単に扱うことができます。

このステップでは、PlayerPrefsの使い方と注意点を解説します！

PlayerPrefsとは？

PlayerPrefsは、Unityが提供するキーと値の組み合わせでデータを保存するシンプルな仕組みです。
具体的には、次のようなデータを保存するのに向いています。

✅ プレイヤーのスコア
✅ 音量や難易度の設定
✅ ゲームの進行状況（レベルクリア情報など）

保存したデータはゲームを終了しても保持されるので、次回のプレイ時にも利用できます！

PlayerPrefsの基本的な使い方

① データを保存する

データを保存するには、PlayerPrefs.SetInt() などの関数を使います。

// スコアを保存
PlayerPrefs.SetInt("HighScore", 10000);

// BGMの音量（0.0〜1.0）を保存
PlayerPrefs.SetFloat("BGMVolume", 0.8f);

// ユーザー名を保存
PlayerPrefs.SetString("UserName", "Player1");

// 保存を確定
PlayerPrefs.Save();

⚠️ PlayerPrefs.Save(); は省略可能ですが、確実に保存したい場合は実行しましょう！

② データを読み込む

保存したデータを取得するには、PlayerPrefs.GetInt() などの関数を使います。

// スコアを読み込む（デフォルト値は 0）
int highScore = PlayerPrefs.GetInt("HighScore", 0);
Debug.Log("ハイスコア：" + highScore);

// 音量を読み込む（デフォルト値は 1.0）
float volume = PlayerPrefs.GetFloat("BGMVolume", 1.0f);
Debug.Log("BGMの音量：" + volume);

// ユーザー名を読み込む（デフォルト値は "Guest"）
string userName = PlayerPrefs.GetString("UserName", "Guest");
Debug.Log("プレイヤー名：" + userName);

⚠️ キーが存在しない場合は、指定したデフォルト値が返されます！

③ データを削除する

保存したデータを削除することもできます。

// "HighScore" のデータを削除
PlayerPrefs.DeleteKey("HighScore");

// 全てのデータを削除
PlayerPrefs.DeleteAll();

⚠️ DeleteAll() を実行すると、すべてのデータが削除されるので注意！

PlayerPrefsの注意点

PlayerPrefsは便利ですが、いくつかの制限があります。

❌ 大容量データの保存には向かない
PlayerPrefsは主に 小さなデータ（数値・文字列） の保存に適しており、大きなデータ（画像・複雑なオブジェクトなど）は保存できません。

❌ セキュリティは弱い
PlayerPrefsのデータは簡単に書き換えられてしまうため、チート対策が必要なデータの保存には向きません。（例：オンラインランキングのスコアなど）

✅ セーブデータをしっかり管理したいならJSONやバイナリを使おう！
ゲームの進行状況や詳細な設定を保存したい場合は、JsonUtility や BinaryFormatter を使ったシリアライズを検討しましょう！

まとめ

• PlayerPrefsは、ゲームの設定やスコアを簡単に保存できる便利な機能！
• キーと値の組み合わせでデータを管理でき、整数・浮動小数点・文字列を保存可能。
• 大容量データやセキュリティが必要なデータには向かない。
• ゲームの設定や簡単なデータ保存には最適！

PlayerPrefs は、設定データなどの小規模なデータ保存には便利ですが、大きなデータを扱うには限界があります。
また、暗号化もされていないため、プレイヤーがデータを書き換えてしまうリスクもあります。

「もっと柔軟に、しかもセキュアにデータを保存したい！」という方には、
Easy Save がオススメです！

🎯 PlayerPrefsのようにシンプルな操作感で、もっと強力な機能！
🎯 大容量データの保存＆復元も簡単！
🎯 暗号化機能つきで、改ざんを防止！

「PlayerPrefsだけでは不安…」という方は、ぜひEasy Saveを試してみてください！

これで、Unityの PlayerPrefs を活用して、ゲームの設定やスコアを保存できるようになりました！次は、より高度な JSONやバイナリシリアライズ を学んで、データ管理をレベルアップさせましょう！ 🚀

8. データの暗号化とセキュリティ

ゲームデータをシリアライズして保存する場合、そのままの形式ではプレイヤーに簡単にアクセスされてしまいます。特に、JSONやバイナリ形式のファイルは開くと中身がそのまま見えてしまうことが多く、不正な改ざんやチートの原因になります。そこで、データを暗号化して保存することで、ゲームのセキュリティを強化しましょう。

1. なぜデータの暗号化が必要なのか？

シリアライズしたデータがそのままの状態で保存されると、以下のような問題が発生する可能性があります。

• プレイヤーがデータを改ざんする
  • 例：ゲーム内通貨やスコアを変更してチートする
• ゲームの設定や進行状況が簡単に変更される
  • 例：ロックされているステージを強制的に解放する
• 他のプレイヤーと共有してしまう
  • 例：オンラインゲームで、特定のアイテムを無料で取得するために改ざんデータを共有する

これらの問題を防ぐために、シリアライズしたデータを暗号化する方法を見ていきましょう。

2. 簡単な暗号化方法（XOR暗号）

最も簡単な暗号化方法の1つが XOR演算 を使う方法です。XOR演算は、同じキーで再度XORをかけると元のデータに戻る特性を持つため、シンプルながら手軽に暗号化できます。

XOR暗号を使ったデータ保存

以下のコードでは、XOR演算を使ってJSONデータを暗号化して保存する方法を紹介します。

using System;
using System.IO;
using UnityEngine;

[Serializable]
public class PlayerData
{
    public int score;
    public int coins;
}

public class DataManager : MonoBehaviour
{
    private static string key = "SecretKey"; // 暗号化キー

    public static void SaveData(PlayerData data)
    {
        string json = JsonUtility.ToJson(data);
        string encryptedJson = EncryptDecrypt(json);

        File.WriteAllText(Application.persistentDataPath + "/save.dat", encryptedJson);
        Debug.Log("データを保存しました: " + encryptedJson);
    }

    public static PlayerData LoadData()
    {
        string path = Application.persistentDataPath + "/save.dat";
        if (File.Exists(path))
        {
            string encryptedJson = File.ReadAllText(path);
            string decryptedJson = EncryptDecrypt(encryptedJson);
            return JsonUtility.FromJson<PlayerData>(decryptedJson);
        }
        else
        {
            Debug.LogWarning("保存データが見つかりません！");
            return null;
        }
    }

    private static string EncryptDecrypt(string data)
    {
        char[] charArray = data.ToCharArray();
        char[] keyArray = key.ToCharArray();

        for (int i = 0; i < charArray.Length; i++)
        {
            charArray[i] = (char)(charArray[i] ^ keyArray[i % keyArray.Length]);
        }

        return new string(charArray);
    }
}

解説

1. JsonUtility.ToJson() を使って PlayerData をJSONに変換
2. EncryptDecrypt() メソッドでXOR暗号化
3. File.WriteAllText() で暗号化データを保存
4. 読み込む際は、逆にXOR暗号を適用して復号する

これはシンプルな暗号化ですが、軽いセキュリティ対策として役立ちます。

3. より強力な暗号化（AES暗号）

XOR暗号はシンプルですが、十分なセキュリティを提供するものではありません。もっと強力な暗号化をしたい場合は AES（Advanced Encryption Standard） を使いましょう。

AES暗号化をUnityで使うには System.Security.Cryptography を利用します。以下はAESを使ってデータを暗号化・復号する方法です。

AES暗号を使ったデータ保存

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using UnityEngine;

public class AESManager
{
    private static string key = "1234567890123456"; // 16文字のキー（変更可）
    private static string iv = "6543210987654321";  // 16文字のIV（変更可）

    public static string Encrypt(string plainText)
    {
        byte[] keyBytes = Encoding.UTF8.GetBytes(key);
        byte[] ivBytes = Encoding.UTF8.GetBytes(iv);
        byte[] plainBytes = Encoding.UTF8.GetBytes(plainText);

        using (Aes aes = Aes.Create())
        {
            aes.Key = keyBytes;
            aes.IV = ivBytes;
            ICryptoTransform encryptor = aes.CreateEncryptor();

            byte[] encryptedBytes = encryptor.TransformFinalBlock(plainBytes, 0, plainBytes.Length);
            return Convert.ToBase64String(encryptedBytes);
        }
    }

    public static string Decrypt(string encryptedText)
    {
        byte[] keyBytes = Encoding.UTF8.GetBytes(key);
        byte[] ivBytes = Encoding.UTF8.GetBytes(iv);
        byte[] encryptedBytes = Convert.FromBase64String(encryptedText);

        using (Aes aes = Aes.Create())
        {
            aes.Key = keyBytes;
            aes.IV = ivBytes;
            ICryptoTransform decryptor = aes.CreateDecryptor();

            byte[] decryptedBytes = decryptor.TransformFinalBlock(encryptedBytes, 0, encryptedBytes.Length);
            return Encoding.UTF8.GetString(decryptedBytes);
        }
    }
}

解説

1. Encrypt() でテキストデータをAES暗号化
2. Decrypt() で復号化
3. key と iv（初期化ベクトル）を16文字の固定値で設定
4. Convert.ToBase64String() を使って暗号化データを文字列として保存

AESを使ったデータ保存の流れ

string jsonData = JsonUtility.ToJson(playerData);
string encryptedData = AESManager.Encrypt(jsonData);
File.WriteAllText(Application.persistentDataPath + "/save.dat", encryptedData);

復号する場合:

string encryptedData = File.ReadAllText(Application.persistentDataPath + "/save.dat");
string jsonData = AESManager.Decrypt(encryptedData);
PlayerData loadedData = JsonUtility.FromJson<PlayerData>(jsonData);

AES暗号を使うことで、改ざん耐性のあるデータを保存できます。

4. まとめ

• シリアライズしたデータはそのままでは改ざんされやすい
• 簡易的な暗号化なら XOR暗号 を使う
• 強力な暗号化をしたい場合は AES暗号 を使う
• ゲームの進行状況やアイテムデータを守るために、適切な暗号化を導入しよう

シリアライズしたデータをそのまま保存すると、プレイヤーが簡単に改ざんできるリスクがあります。
特に、スコアや課金データ、ゲーム進行情報を守りたい場合、暗号化は必須です。

Unity標準のJsonUtilityやBinaryFormatterには暗号化機能がないため、
セキュアなデータ保存を実現するなら Easy Save を使うのがベスト！

🔐 AES暗号化でデータをしっかり保護
🔐 JSONもバイナリも暗号化OK
🔐 セーブデータの復元や改ざん防止も簡単に！

「ゲームのデータを安全に守りたい！」という人は、ぜひEasy Saveを導入してみてください。

データのセキュリティをしっかり管理することで、プレイヤーが不正にゲームバランスを壊すのを防ぐことができます。シリアライズと暗号化を組み合わせて、安全なデータ管理を実装しましょう！

9. シリアライズを活用した応用テクニック

Unityでゲームを作る際、シリアライズを使えば、データの保存・読み込みを自由自在にコントロールできます。ここでは、シリアライズの応用テクニックとして、設定データの自動保存とロード、ゲームの進行状況のセーブ＆ロード、ネットワーク経由でのデータ送受信 の3つの方法を解説します。

9.1 設定データの自動保存とロード

ゲームの設定（音量、グラフィック品質、操作設定など）を保存して、次回起動時にも反映させるには、シリアライズを活用するのが便利です。
ここでは JSONを使って設定データを保存＆ロード する方法を紹介します。

① 設定データを管理するクラスを作成

まず、ゲームの設定を保存するためのクラスを作成します。

[System.Serializable]
public class GameSettings
{
    public float volume = 1.0f;
    public int resolutionIndex = 0;
    public bool isFullScreen = true;
}

このクラスは [System.Serializable] をつけることで、JSON形式に変換できるようになります。

② 設定をJSONで保存

次に、設定データをJSONとして保存するコードを書きます。

using UnityEngine;
using System.IO;

public class SettingsManager : MonoBehaviour
{
    private string filePath;

    void Start()
    {
        filePath = Application.persistentDataPath + "/settings.json";
        LoadSettings(); // 起動時に設定を読み込む
    }

    public void SaveSettings(GameSettings settings)
    {
        string json = JsonUtility.ToJson(settings, true);
        File.WriteAllText(filePath, json);
        Debug.Log("設定を保存しました: " + filePath);
    }

    public GameSettings LoadSettings()
    {
        if (File.Exists(filePath))
        {
            string json = File.ReadAllText(filePath);
            return JsonUtility.FromJson<GameSettings>(json);
        }
        return new GameSettings(); // デフォルト設定を返す
    }
}

これで、設定を保存すると settings.json にデータが書き込まれ、ゲームを再起動しても設定が保持されるようになります。

9.2 ゲームの進行状況のセーブ＆ロード

ゲームの進行状況（プレイヤーの位置、レベル、アイテムなど）を保存し、再開時に復元するには、バイナリシリアライズ を活用すると高速でデータを扱えます。

① セーブデータ用のクラスを作成

ゲームの進行状況を保存するクラスを作成します。

[System.Serializable]
public class SaveData
{
    public int playerLevel;
    public float playerHealth;
    public Vector3 playerPosition;
}

② バイナリ形式でデータを保存

次に、バイナリデータとして保存するスクリプトを作成します。

using UnityEngine;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

public class SaveManager : MonoBehaviour
{
    private string savePath;

    void Start()
    {
        savePath = Application.persistentDataPath + "/savefile.dat";
    }

    public void SaveGame(SaveData data)
    {
        BinaryFormatter formatter = new BinaryFormatter();
        FileStream stream = new FileStream(savePath, FileMode.Create);

        formatter.Serialize(stream, data);
        stream.Close();
        Debug.Log("ゲームデータを保存しました: " + savePath);
    }

    public SaveData LoadGame()
    {
        if (File.Exists(savePath))
        {
            BinaryFormatter formatter = new BinaryFormatter();
            FileStream stream = new FileStream(savePath, FileMode.Open);

            SaveData data = formatter.Deserialize(stream) as SaveData;
            stream.Close();
            return data;
        }
        else
        {
            Debug.Log("セーブデータが見つかりません");
            return null;
        }
    }
}

このコードを使えば、プレイヤーのレベルやHP、位置データをバイナリ形式で保存し、ゲーム再開時に復元できます。

9.3 ネットワーク経由でのデータ送受信

オンラインゲームやクラウドストレージを使う場合、データをローカルに保存するのではなく、サーバーと通信して送受信 することが重要になります。
ここでは、Firebaseを使ってJSON形式でデータを送受信 する例を紹介します。

① Firebaseのセットアップ

1. Firebaseのプロジェクトを作成し、Unity SDKを導入
2. Firebase Realtime Databaseを有効化

② Firebaseにデータを送信

Firebaseのデータベースにプレイヤーのスコアを保存するスクリプトです。

using Firebase.Database;
using UnityEngine;

public class FirebaseManager : MonoBehaviour
{
    private DatabaseReference databaseReference;

    void Start()
    {
        databaseReference = FirebaseDatabase.DefaultInstance.RootReference;
    }

    public void SavePlayerScore(string playerName, int score)
    {
        databaseReference.Child("players").Child(playerName).SetValueAsync(score);
        Debug.Log("スコアを保存しました: " + playerName + " - " + score);
    }
}

③ Firebaseからデータを取得

次に、データベースに保存したスコアを取得するコードです。

public void LoadPlayerScore(string playerName)
{
    databaseReference.Child("players").Child(playerName).GetValueAsync().ContinueWith(task =>
    {
        if (task.IsCompleted)
        {
            DataSnapshot snapshot = task.Result;
            int score = int.Parse(snapshot.Value.ToString());
            Debug.Log(playerName + " のスコア: " + score);
        }
    });
}

これにより、オンライン上でデータを保存し、いつでもどこでも復元できるようになります。

まとめ

• 設定データの自動保存 は JSON を使って簡単に実装可能！
• ゲームの進行状況の保存 には バイナリシリアライズを使うと高速！
• ネットワーク経由のデータ送受信 には Firebase などのクラウドサービスを活用！

シリアライズを活用すると、ゲームの進行状況や設定データを簡単に保存できます。ただし、大量のデータを扱う場合や、複雑なデータ構造を管理する際は、標準のインスペクターだと不便なことも。
Odin Inspector and Serializer を使えば、インスペクターのUIをカスタマイズし、データの管理をより直感的に行えます。

これらのテクニックを駆使すれば、データ管理がグッと楽になり、ゲーム開発がスムーズに進むようになります！

10. まとめ

ここまで、Unityにおけるシリアライズの基本から応用テクニックまでを解説してきました。データを効率よく保存・読み込みすることで、ゲームの状態を維持したり、プレイヤーの設定を保存したりと、さまざまな場面で役立ちます。

🔹 シリアライズのポイントをおさらい！

1. シリアライズとは？
   • データを保存・読み込みしやすい形式に変換する仕組み。
   • Unityでは SerializeField や JsonUtility を使って簡単に実装可能。
2. JSONを使ったデータ管理
   • JsonUtility を使えば、簡単にJSONデータの保存・読み込みができる。
   • 可読性が高く、デバッグしやすい。
3. バイナリシリアライズの活用
   • BinaryFormatter を使うことで、データを圧縮して高速に処理できる。
   • JSONよりもデータサイズを小さくできるが、可読性は低い。
4. ScriptableObjectを活用
   • ゲームデータを簡単に管理・共有できる便利な方法。
   • 設定データやアイテムデータなど、静的なデータ管理に最適。
5. PlayerPrefsの利用
   • ゲームの設定やスコアなど、小さなデータの保存に適している。
   • 大量のデータには向かないので、使用する場面を考える。
6. データのセキュリティ対策
   • ユーザーのプライバシーを守るために暗号化を活用。
   • 保存データをそのまま読み取られないようにする工夫が必要。

🔹 シリアライズを活用して、より便利なゲーム開発を！ データの保存・読み込みを適切に管理することで、よりスムーズなゲーム開発が可能になります。シリアライズの知識を活かして、セーブ機能やカスタム設定の実装、さらにはクラウドと連携したデータ保存など、さまざまな応用を試してみてください！

次のステップとして、
✅ FirebaseやPlayFabを使ったオンラインデータ管理
✅ Unityでのセーブ＆ロードシステムの実装
✅ 暗号化を用いた安全なデータ保存方法
などを学ぶと、さらにレベルアップできます！

これで、Unityのシリアライズについてのガイドは終了です。ぜひ実際に試しながら、自分のゲーム開発に活かしてください！ 🚀

よくある質問（FAQ）

【初心者向け】Unityでステージ選択システムを実装！クリア後に次のステージを解放しよう

Unityでステージクリア後に次のステージを選択可能にする方法を解説！PlayerPrefsを活用して進行度を保存し、ステージ解放ボタンを管理する方法を初心者向けにわかりやすく解説します。

cbagames.jp

Unity初心者必見！ハイスコアをセーブ＆リセットする仕組みを作ろう

Unity初心者向けに、PlayerPrefsを使ったハイスコアのセーブ＆リセット方法を解説！スコアをクリックで増やす簡単な仕組みも紹介します。

cbagames.jp

Unity初心者必見！Asset Storeで手に入るゲーム制作が楽になるおすすめアセット

Unity Asset Storeで手に入るゲーム制作が楽になるおすすめアセットを厳選紹介！ゲーム制作を効率化し、クオリティをアップさせる便利なツールやテンプレートなどを紹介！

cbagames.jp

関連記事:

【実践】UnityでJSONデータ管理！セーブ＆ロードを最適化する方法Unity初心者必見！Easy Save 3でスムーズなデータ管理を実現する方法【Unity入門】2Dシューティングゲームを簡単に作る手順を解説【Unity】ツムツム風パズルゲームを作ろう！初心者向け完全ガイド【Unity初心者向け】2Dブロック崩しゲームの作り方を解説！Unityのスクリプト設計を改善！SOLID原則で整理する方法【Unity】2Dタワーディフェンスゲームの作り方②！武器配置と弾の発射を実装【Unity C#】カスタムイベントの作り方！EventとActionを使いこなそうUnityでオブジェクトプールを実装する方法と最適化ポイントUnity初心者が最初に作るべきゲーム5選！楽しく学べるステップバイステップガイド