Unity游戏开发实战：从PlayerPrefs到JSON，精通游戏存档与加载机制

Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南
02-玩转 LangChain Memory 模块：四种记忆类型详解及应用场景全覆盖
03-全面掌握 LangChain：从核心链条构建到动态任务分配的实战指南
04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 掌握 LangChain Agents：自定义工具 + LLM 打造智能工作流！
07-【深度解析】从GPT-1到GPT-4：ChatGPT背后的核心原理全揭秘

PyTorch系列文章目录

Python系列文章目录

C#系列文章目录

01-C#与游戏开发的初次见面：从零开始的Unity之旅
02-C#入门：从变量与数据类型开始你的游戏开发之旅
03-C#运算符与表达式：从入门到游戏伤害计算实践
04-从零开始学C#：用if-else和switch打造智能游戏逻辑
05-掌握C#循环：for、while、break与continue详解及游戏案例
06-玩转C#函数：参数、返回值与游戏中的攻击逻辑封装
07-Unity游戏开发入门：用C#控制游戏对象移动
08-C#面向对象编程基础：类的定义、属性与字段详解
09-C#封装与访问修饰符：保护数据安全的利器
10-如何用C#继承提升游戏开发效率？Enemy与Boss案例解析
11-C#多态性入门：从零到游戏开发实战
12-C#接口王者之路：从入门到Unity游戏开发实战 (IAttackable案例详解)
13-C#静态成员揭秘：共享数据与方法的利器
14-Unity 面向对象实战：掌握组件化设计与脚本通信，构建玩家敌人交互
15-C#入门 Day15：彻底搞懂数组！从基础到游戏子弹管理实战
16-C# List 从入门到实战：掌握动态数组，轻松管理游戏敌人列表 (含代码示例)
17-C# 字典 (Dictionary) 完全指南：从入门到游戏属性表实战 (Day 17)
18-C#游戏开发【第18天】 | 深入理解队列(Queue)与栈(Stack)：从基础到任务队列实战
19-【C# 进阶】深入理解枚举 Flags 属性：游戏开发中多状态组合的利器
20-C#结构体(Struct)深度解析：轻量数据容器与游戏开发应用 (Day 20)
21-Unity数据持久化进阶：告别硬编码，用ScriptableObject优雅管理游戏配置！(Day 21)
22-Unity C# 健壮性编程：告别崩溃！掌握异常处理与调试的 4 大核心技巧 (Day 22)
23-C#代码解耦利器：委托与事件（Delegate & Event）从入门到实践 (Day 23)
24-Unity脚本通信终极指南：从0到1精通UnityEvent与事件解耦（Day 24）
25-精通C# Lambda与LINQ：Unity数据处理效率提升10倍的秘诀！ (Day 25)
26-# Unity C#进阶：掌握泛型编程，告别重复代码，编写优雅复用的通用组件！（Day26）
27-Unity协程从入门到精通：告别卡顿，用Coroutine优雅处理异步与时序任务 (Day 27)
28-搞定玩家控制！Unity输入系统、物理引擎、碰撞检测实战指南 (Day 28)
29-# Unity动画控制核心：Animator状态机与C#脚本实战指南 (Day 29)
30-Unity UI 从零到精通 (第30天): Canvas、布局与C#交互实战 (Day 30)
31-Unity性能优化利器：彻底搞懂对象池技术（附C#实现与源码解析）
32-Unity C#进阶：用状态模式与FSM优雅管理复杂敌人AI，告别Spaghetti Code！（Day32）
33-Unity游戏开发实战：从PlayerPrefs到JSON，精通游戏存档与加载机制（Day 33）

---

---

前言

欢迎来到我们《C# for Unity》专栏的第33天！在之前的学习中，我们已经掌握了C#的基础语法、面向对象编程、数据结构以及Unity的许多核心机制。今天，我们将聚焦一个对几乎所有游戏都至关重要的功能——游戏存档与加载。想象一下，玩家投入了数小时精心培养的角色、探索的世界、积累的财富，如果因为游戏关闭而全部丢失，那将是多么糟糕的体验！数据持久化，即将游戏状态和玩家数据保存下来以便后续恢复，是提升玩家留存率和满意度的关键。

本篇文章将带你从最简单的PlayerPrefs入手，逐步深入到使用JSON进行复杂数据的序列化与反序列化，结合文件读写操作，最终实现一个相对完善的游戏存档与加载系统。我们还会初步探讨数据安全性的问题。无论你是刚接触Unity的新手，还是希望系统梳理存档机制的进阶开发者，相信本文都能为你提供清晰的指引和实用的代码示例。

一、为什么需要游戏存档？

游戏存档的核心目标是持久化游戏进度与玩家数据。这意味着当玩家退出游戏或设备关闭后，他们的关键信息不会丢失，下次启动时可以从上次离开的地方继续。

1.1 提升玩家体验

• 保留进度：允许玩家中断游戏，并在方便时恢复，尤其对于耗时较长的游戏至关重要。
• 成就感积累：玩家的等级、得分、收集品等是他们投入时间和精力的证明，存档能保留这些成就感。
• 个性化设置：如图形选项、音量、键位绑定等用户偏好设置也需要被保存。

1.2 需要保存哪些数据？

根据游戏类型的不同，需要保存的数据也千差万别，常见的包括：

• 玩家状态：位置、旋转、生命值、魔法值、经验值、等级。
• 游戏进度：当前关卡、已完成的任务、剧情节点。
• 资源与物品：金币、宝石、道具、装备、技能。
• 游戏设置：音量、画质、控制偏好。
• 世界状态：某些需要动态保存的场景元素状态（如已打开的宝箱、已击败的特定敌人）。

了解了存档的重要性与内容后，我们开始探索具体的实现方法。

二、初探：PlayerPrefs的简单使用与局限性

Unity提供了一个非常便捷的内置类PlayerPrefs，用于在本地持久化存储简单的键值对数据。它非常适合存储少量、非关键性的数据，如玩家设置或最高分。

2.1 PlayerPrefs是什么？

PlayerPrefs本质上是在目标平台上使用一种简单的方式来存储和访问玩家偏好设置。

• 工作原理：它将数据存储在特定于平台的位置（例如Windows上的注册表，macOS/iOS/Android上的特定文件）。
• 数据类型：主要支持存储int, float, string三种基本数据类型。可以通过SetInt(), SetFloat(), SetString()来保存，通过GetInt(), GetFloat(), GetString()来读取。
• 核心操作：
  • PlayerPrefs.SetInt(string key, int value): 保存一个整数。
  • PlayerPrefs.GetInt(string key, int defaultValue = 0): 读取一个整数，如果键不存在则返回默认值。
  • PlayerPrefs.SetFloat(string key, float value): 保存一个浮点数。
  • PlayerPrefs.GetFloat(string key, float defaultValue = 0.0f): 读取一个浮点数。
  • PlayerPrefs.SetString(string key, string value): 保存一个字符串。
  • PlayerPrefs.GetString(string key, string defaultValue = ""): 读取一个字符串。
  • PlayerPrefs.HasKey(string key): 检查某个键是否存在。
  • PlayerPrefs.DeleteKey(string key): 删除指定的键值对。
  • PlayerPrefs.DeleteAll(): 删除所有PlayerPrefs数据（慎用！）。
  • PlayerPrefs.Save(): 将修改写入磁盘（通常Unity会在应用退出时自动调用，但关键时刻手动调用更保险）。

2.2 使用示例：保存最高分

假设我们想保存玩家的最高分：

using UnityEngine;
using UnityEngine.UI; // 假设有个Text显示最高分public class HighScoreManager : MonoBehaviour
{public Text highScoreText;private const string HighScoreKey = "HighScore"; // 定义键名常量，避免拼写错误void Start(){LoadHighScore();}public void TryUpdateHighScore(int currentScore){int highScore = PlayerPrefs.GetInt(HighScoreKey, 0); // 读取当前最高分，默认为0if (currentScore > highScore){PlayerPrefs.SetInt(HighScoreKey, currentScore); // 更新最高分PlayerPrefs.Save(); // 立即保存到磁盘Debug.Log($"New High Score: {currentScore}");UpdateHighScoreText(currentScore);}}void LoadHighScore(){int highScore = PlayerPrefs.GetInt(HighScoreKey, 0);UpdateHighScoreText(highScore);}void UpdateHighScoreText(int score){if (highScoreText != null){highScoreText.text = "High Score: " + score;}}// (可选) 提供一个重置最高分的方法public void ResetHighScore(){PlayerPrefs.DeleteKey(HighScoreKey);PlayerPrefs.Save();LoadHighScore(); // 重新加载并更新显示Debug.Log("High Score Reset.");}
}

2.3 PlayerPrefs的局限性

尽管PlayerPrefs简单易用，但它有明显的局限性，不适合存储复杂或大量的游戏数据：

• 数据类型有限：只能直接存储int, float, string。存储其他类型（如bool, Vector3, List, 自定义类）需要手动转换或编码，非常繁琐。
• 缺乏结构化：只能存储扁平的键值对，难以表示复杂的数据关系（如玩家的物品栏，包含多个物品，每个物品有多个属性）。
• 性能问题：对于大量数据的读写，性能可能不高。
• 安全性差：数据通常以明文或易于解码的方式存储，玩家可以轻易找到并修改存档文件，导致作弊。
• 平台差异：虽然API统一，但底层存储机制和位置因平台而异，有时可能遇到特定平台的限制或问题。

因此，当我们需要保存更复杂的游戏状态时，就需要更强大的解决方案。

三、进阶：使用JSON进行复杂数据的序列化与反序列化

为了克服PlayerPrefs的局限性，我们需要一种能将内存中的复杂数据结构（如类的对象、列表、字典等）转换为可存储或传输的格式（如字符串），并在需要时将其还原回内存对象的方法。这个过程就是序列化（Serialization）和反序列化（Deserialization）。

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，因其易于人阅读和编写，同时也易于机器解析和生成，而广泛应用于数据存储和网络通信。Unity内置了对JSON的支持，并且我们也可以引入更强大的第三方库。

3.1 序列化与反序列化基础

• 序列化：将内存中的对象（如一个PlayerData类的实例）转换成一个字节流或字符串（例如JSON格式的字符串），以便存储到文件或通过网络发送。
• 反序列化：将存储在文件或接收到的字节流/字符串（例如JSON格式的字符串）解析并转换回内存中的对象。

graph LRA[内存中的对象 (Object in Memory)] -- 序列化 (Serialization) --> B(JSON字符串/字节流);B -- 反序列化 (Deserialization) --> A;

3.2 Unity内置的JsonUtility

Unity提供了一个内置的JsonUtility类，可以方便地将可序列化的公有字段或标记了[SerializeField]特性的私有字段的对象转换为JSON字符串，反之亦然。

3.2.1 定义可序列化的数据类

要使用JsonUtility，你需要定义一个包含要保存数据的类或结构体，并确保该类或结构体本身以及其需要序列化的字段是符合Unity序列化规则的。通常，这意味着类需要标记[System.Serializable]特性。

using UnityEngine;
using System.Collections.Generic; // 如果有列表等[System.Serializable] // 必须标记这个特性，JsonUtility才能处理
public class PlayerData
{public Vector3 playerPosition; // 公有字段会被序列化public int score;public List<string> inventoryItems; // 列表也可以被序列化[SerializeField] // 私有字段需要这个特性才能被序列化private int playerLevel;// 构造函数（可选，方便创建实例）public PlayerData(Vector3 pos, int scr, List<string> items, int level){playerPosition = pos;score = scr;inventoryItems = items ?? new List<string>(); // 防御nullplayerLevel = level;}// 提供一个获取私有字段的方法（如果需要）public int GetLevel() => playerLevel;
}

3.2.2 使用JsonUtility进行序列化与反序列化

using UnityEngine;
using System.Collections.Generic;public class JsonExample : MonoBehaviour
{void Start(){// 1. 创建数据对象实例List<string> items = new List<string> { "Sword", "Potion", "Key" };PlayerData dataToSave = new PlayerData(new Vector3(10.5f, 0f, -5f), 1500, items, 5);// 2. 序列化对象到JSON字符串string jsonString = JsonUtility.ToJson(dataToSave, true); // 第二个参数true表示格式化输出（易读）Debug.Log("Serialized JSON:\n" + jsonString);// 假设我们将jsonString保存到文件，然后读取回来...string jsonReadFromFile = jsonString; // 这里模拟从文件读取// 3. 反序列化JSON字符串回对象PlayerData loadedData = JsonUtility.FromJson<PlayerData>(jsonReadFromFile);// 4. 验证数据Debug.Log("Loaded Data:");Debug.Log($"Position: {loadedData.playerPosition}");Debug.Log($"Score: {loadedData.score}");Debug.Log($"Level: {loadedData.GetLevel()}"); // 注意访问私有字段的方式Debug.Log("Inventory:");foreach (var item in loadedData.inventoryItems){Debug.Log($"- {item}");}}
}

3.2.3 JsonUtility的限制

JsonUtility虽然方便，但也有一些重要的限制：

• 不支持字典（Dictionary）：无法直接序列化Dictionary<TKey, TValue>类型。
• 不支持多态：如果一个字段是基类类型，但实际赋值是子类实例，JsonUtility只会序列化基类的字段。
• 根对象要求：ToJson只能直接序列化单个对象，不能直接序列化数组或列表（需要将它们包装在一个类中）。
• 对非Unity内置类型支持有限：主要设计用于序列化Unity能够理解的类型（如基本类型、Vector3、Quaternion、以及标记了[System.Serializable]的自定义类/结构体）。

3.3 更强大的选择：Newtonsoft.Json (Json.NET)

当JsonUtility无法满足需求时（例如需要序列化字典、处理复杂继承关系、或者需要更精细的控制），开发者通常会选择使用Newtonsoft.Json（也称为Json.NET）。这是一个功能非常强大且广泛使用的第三方JSON库。

3.3.1 在Unity中安装Newtonsoft.Json

可以通过Unity的Package Manager来安装。

1. 打开 Window > Package Manager。
2. 点击左上角的 + 号，选择 Add package from git URL...。
3. 输入 com.unity.nuget.newtonsoft-json 并点击 Add。 (请注意：包名可能会随Unity版本更新，请查阅最新文档确认)
   • 或者，在某些Unity版本中可能内置或通过其他方式引入。也可以直接下载其.dll文件放入项目Assets目录下。

3.3.2 使用Newtonsoft.Json

// 需要先安装Newtonsoft.Json包
using UnityEngine;
using Newtonsoft.Json; // 引入命名空间
using System.Collections.Generic;// PlayerData类可以保持不变，Newtonsoft.Json通常不需要[System.Serializable]
// 但如果同时也要被Unity序列化（如在Inspector中显示），则保留
[System.Serializable] // 保留以便Inspector显示，但Newtonsoft不强制要求
public class PlayerDataAdvanced
{public Vector3 playerPosition;public int score;public List<string> inventoryItems;public Dictionary<string, int> skillLevels; // JsonUtility不支持字典，但Newtonsoft支持// Newtonsoft可以序列化属性public string PlayerName { get; set; }// Newtonsoft可以更好地处理私有成员（需要配置或使用特性）[JsonProperty] // 使用JsonProperty特性明确指示序列化私有字段private int playerLevel;// 无参构造函数对某些反序列化场景有帮助public PlayerDataAdvanced() { }public PlayerDataAdvanced(Vector3 pos, int scr, List<string> items, Dictionary<string, int> skills, string name, int level){playerPosition = pos;score = scr;inventoryItems = items ?? new List<string>();skillLevels = skills ?? new Dictionary<string, int>();PlayerName = name;playerLevel = level;}public int GetLevel() => playerLevel;
}public class NewtonsoftExample : MonoBehaviour
{void Start(){// 1. 创建数据对象实例List<string> items = new List<string> { "Axe", "Shield" };Dictionary<string, int> skills = new Dictionary<string, int>{{ "Fireball", 3 },{ "Heal", 2 }};PlayerDataAdvanced dataToSave = new PlayerDataAdvanced(Vector3.zero, 2000, items, skills, "Hero123", 8);// 2. 使用Newtonsoft.Json序列化// 可以配置序列化设置，例如格式化、忽略Null值等JsonSerializerSettings settings = new JsonSerializerSettings{Formatting = Formatting.Indented, // 格式化输出ReferenceLoopHandling = ReferenceLoopHandling.Ignore // 处理循环引用（如果需要）};string jsonString = JsonConvert.SerializeObject(dataToSave, settings);Debug.Log("Newtonsoft Serialized JSON:\n" + jsonString);// 假设保存并读取...string jsonReadFromFile = jsonString;// 3. 使用Newtonsoft.Json反序列化PlayerDataAdvanced loadedData = JsonConvert.DeserializeObject<PlayerDataAdvanced>(jsonReadFromFile);// 4. 验证数据Debug.Log("Newtonsoft Loaded Data:");Debug.Log($"Position: {loadedData.playerPosition}");Debug.Log($"Score: {loadedData.score}");Debug.Log($"Name: {loadedData.PlayerName}");Debug.Log($"Level: {loadedData.GetLevel()}");Debug.Log("Inventory:");foreach (var item in loadedData.inventoryItems) Debug.Log($"- {item}");Debug.Log("Skills:");foreach (var kvp in loadedData.skillLevels) Debug.Log($"- {kvp.Key}: Level {kvp.Value}");}
}

Newtonsoft.Json提供了更丰富的功能和更高的灵活性，但相应地也可能带来轻微的性能开销和对项目依赖的增加。通常建议：简单场景用JsonUtility，复杂场景或需要高级特性时用Newtonsoft.Json。

四、核心操作：文件读写 (System.IO)

将数据序列化为JSON字符串后，我们需要将其写入文件进行持久化存储，并在需要时从文件中读取出来。这需要使用C#的System.IO命名空间下的类。

4.1 获取安全的存档路径

直接将存档文件放在项目根目录或随意位置是不推荐的。Unity提供了一个专门用于存储持久化数据的路径：Application.persistentDataPath。

• Application.persistentDataPath: 这个路径指向一个设备上用户特定的、可读写的目录，即使游戏更新也不会被清除。这是存储存档、配置文件等的理想位置。
  • Windows: C:\Users\<username>\AppData\LocalLow\<CompanyName>\<ProductName>
  • macOS: ~/Library/Application Support/<CompanyName>/<ProductName>
  • Linux: ~/.config/unity3d/<CompanyName>/<ProductName>
  • iOS: 应用沙盒中的 Documents 目录 (会被iCloud备份)
  • Android: 应用私有存储空间中的 files 目录 /storage/emulated/0/Android/data/<packagename>/files (通常)

4.2 文件写入 (File.WriteAllText)

使用System.IO.File类的WriteAllText方法可以轻松地将字符串（如JSON）写入文件。

using UnityEngine;
using System.IO; // 必须引入System.IOpublic class FileWriteExample : MonoBehaviour
{public string fileName = "MySaveData.json"; // 定义存档文件名public void SaveStringToFile(string content){// 组合完整的文件路径string filePath = Path.Combine(Application.persistentDataPath, fileName);// On platforms like iOS/Android, Application.persistentDataPath might not exist initially.// It's good practice to ensure the directory exists.string directoryPath = Path.GetDirectoryName(filePath);if (!Directory.Exists(directoryPath)){Directory.CreateDirectory(directoryPath);Debug.Log($"Created directory: {directoryPath}");}try{// 将字符串内容写入指定文件路径，如果文件已存在则覆盖File.WriteAllText(filePath, content);Debug.Log($"Successfully saved data to: {filePath}");}catch (IOException e){Debug.LogError($"Error writing file {filePath}: {e.Message}");// 在这里可以加入更复杂的错误处理逻辑，比如提示用户存档失败}}// 示例调用void Start(){string sampleJson = "{\"playerName\":\"TestPlayer\",\"score\":100}";SaveStringToFile(sampleJson);}
}

注意: 添加了检查并创建目录的代码，这在某些平台（尤其是移动端首次运行时）是必要的，因为persistentDataPath指向的目录可能尚未被创建。

4.3 文件读取 (File.ReadAllText)

使用System.IO.File类的ReadAllText方法可以读取文件的全部内容到一个字符串中。

using UnityEngine;
using System.IO;public class FileReadExample : MonoBehaviour
{public string fileName = "MySaveData.json"; // 确保与写入时使用的文件名一致public string LoadStringFromFile(){string filePath = Path.Combine(Application.persistentDataPath, fileName);// 检查文件是否存在if (File.Exists(filePath)){try{// 读取文件所有内容string content = File.ReadAllText(filePath);Debug.Log($"Successfully loaded data from: {filePath}");return content;}catch (IOException e){Debug.LogError($"Error reading file {filePath}: {e.Message}");return null; // 或抛出异常，根据需要处理}}else{Debug.LogWarning($"Save file not found at: {filePath}");return null; // 文件不存在，返回null或默认值}}// 示例调用void Start(){string loadedJson = LoadStringFromFile();if (loadedJson != null){Debug.Log("Loaded Content:\n" + loadedJson);// 接下来可以将这个json字符串反序列化为对象}}
}

4.4 结合JSON与文件IO

现在我们可以将JSON序列化和文件读写结合起来，形成一个完整的保存和加载流程：

using UnityEngine;
using System.IO;
using Newtonsoft.Json; // 或者 using UnityEngine; 如果用JsonUtilitypublic class SaveLoadManager : MonoBehaviour
{public string saveFileName = "GameData.json";private string FilePath => Path.Combine(Application.persistentDataPath, saveFileName);// 保存游戏数据public void SaveGame(PlayerDataAdvanced data) // 使用之前定义的PlayerDataAdvanced类{// Ensure directory existsstring directoryPath = Path.GetDirectoryName(FilePath);if (!Directory.Exists(directoryPath)){Directory.CreateDirectory(directoryPath);}// 序列化数据为JSON字符串string json = JsonConvert.SerializeObject(data, Formatting.Indented);// 如果使用JsonUtility: string json = JsonUtility.ToJson(data, true);try{// 写入文件File.WriteAllText(FilePath, json);Debug.Log($"Game saved to {FilePath}");}catch (IOException e){Debug.LogError($"Failed to save game data to {FilePath}: {e.Message}");}}// 加载游戏数据public PlayerDataAdvanced LoadGame(){if (File.Exists(FilePath)){try{// 读取JSON字符串string json = File.ReadAllText(FilePath);// 反序列化为对象PlayerDataAdvanced loadedData = JsonConvert.DeserializeObject<PlayerDataAdvanced>(json);// 如果使用JsonUtility: PlayerData loadedData = JsonUtility.FromJson<PlayerData>(json);Debug.Log($"Game loaded from {FilePath}");return loadedData;}catch (IOException e){Debug.LogError($"Failed to load game data from {FilePath}: {e.Message}");return null;}catch (JsonException e) //捕捉JSON解析异常{Debug.LogError($"Error parsing JSON data from {FilePath}: {e.Message}");// 这里可以考虑删除损坏的存档文件或进行其他处理return null;}}else{Debug.LogWarning($"Save file not found at {FilePath}. Returning default data.");return null; // 或者返回一个新建的默认PlayerData对象}}
}

五、安全考量：数据加密与安全性的初步考量

将游戏数据以明文JSON格式存储在用户的设备上，意味着玩家可以轻易地找到存档文件，用文本编辑器打开并修改其中的值（例如，将金币数量改成999999）。这对于单机游戏可能影响不大，但对于有排行榜、成就或任何形式竞争的游戏来说，这会严重破坏公平性。因此，对存档数据进行一定的保护是必要的。

注意： 实现真正安全的加密是一个复杂的领域。以下方法仅提供基础的混淆和保护，对于有决心的攻击者来说仍然可能被破解。对于需要高安全性的在线游戏，通常需要服务器端验证和更专业的加密技术。

5.1 为什么需要加密/混淆？

• 防止作弊：阻止玩家轻易修改存档以获取不公平优势。
• 保护数据完整性：防止存档文件意外损坏或被恶意篡改导致游戏出错。
• （轻微）保护知识产权：虽然不是主要目的，但可以增加他人直接窥探游戏内部数据结构的难度。

5.2 简单的数据混淆方法：Base64编码

Base64不是一种加密算法，而是一种编码方式，它将二进制数据转换成由64个字符（A-Z, a-z, 0-9, +, /）组成的文本字符串。它本身不提供安全性，因为解码是公开和直接的。但它可以：

• 使数据不可直接阅读：打开存档文件看到的是一长串无意义字符，而不是明文JSON。
• 确保数据在某些文本协议中正确传输（虽然在此场景下主要作用是混淆）。

using System;
using System.Text; // 需要引入System.Text来使用Encodingpublic static class DataProtection
{// 使用Base64编码字符串public static string EncodeToBase64(string plainText){if (string.IsNullOrEmpty(plainText)) return plainText;byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);return Convert.ToBase64String(plainTextBytes);}// 从Base64解码字符串public static string DecodeFromBase64(string base64EncodedData){if (string.IsNullOrEmpty(base64EncodedData)) return base64EncodedData;try{byte[] base64EncodedBytes = Convert.FromBase64String(base64EncodedData);return Encoding.UTF8.GetString(base64EncodedBytes);}catch (FormatException e){Debug.LogError($"Error decoding Base64 string: {e.Message}. Input was: {base64EncodedData}");return null; // 或抛出异常}}
}

在SaveLoadManager中应用Base64：

// ... 在 SaveLoadManager 类中 ...public void SaveGame(PlayerDataAdvanced data)
{// ... (确保目录存在) ...string json = JsonConvert.SerializeObject(data, Formatting.Indented);// 在写入前进行Base64编码string encodedJson = DataProtection.EncodeToBase64(json);try{File.WriteAllText(FilePath, encodedJson); // 写入编码后的字符串Debug.Log($"Game saved (encoded) to {FilePath}");}catch (IOException e) { /* ... 错误处理 ... */ }
}public PlayerDataAdvanced LoadGame()
{if (File.Exists(FilePath)){try{string encodedJson = File.ReadAllText(FilePath); // 读取编码后的字符串// 在反序列化前进行Base64解码string json = DataProtection.DecodeFromBase64(encodedJson);if (json == null) {Debug.LogError("Failed to decode save data. File might be corrupted or not Base64.");return null;}PlayerDataAdvanced loadedData = JsonConvert.DeserializeObject<PlayerDataAdvanced>(json);Debug.Log($"Game loaded (decoded) from {FilePath}");return loadedData;}catch (IOException e) { /* ... 错误处理 ... */ return null;}catch (JsonException e) { /* ... 错误处理 ... */ return null;}// 注意: DecodeFromBase64内部已包含FormatException处理}else{// ... (文件不存在的处理) ...return null;}
}

5.3 更进一步：简单的异或(XOR)加密

异或加密是一种非常基础的对称加密方法。它使用一个密钥（可以是一个字符串或字节数组），将数据的每个字节与密钥的对应字节（循环使用）进行异或操作。再次使用相同的密钥进行异或即可解密。

优点：比Base64稍微安全一点，因为需要密钥才能解密。
缺点：仍然非常容易被破解（尤其是密钥过短或模式简单时），不适用于高安全性需求。

using System.Text;public static class SimpleXorEncryption
{private static string secretKey = "YourSecretKeyHere"; // !! 重要：替换成你自己的复杂密钥，且不要硬编码在代码中（更好的做法是从配置或其他安全地方读取）public static string EncryptDecrypt(string data){if (string.IsNullOrEmpty(data)) return data;byte[] keyBytes = Encoding.UTF8.GetBytes(secretKey);byte[] dataBytes = Encoding.UTF8.GetBytes(data);byte[] resultBytes = new byte[dataBytes.Length];for (int i = 0; i < dataBytes.Length; i++){resultBytes[i] = (byte)(dataBytes[i] ^ keyBytes[i % keyBytes.Length]);}// 将结果字节数组转换回UTF8字符串（可能产生无效字符，更好的做法是先Base64编码结果）//return Encoding.UTF8.GetString(resultBytes); // 直接转回字符串可能出问题// 改进：将加密后的字节数组转换为Base64字符串存储，更安全可靠return Convert.ToBase64String(resultBytes);}// 解密时，先Base64解码，再XOR解密public static string DecryptFromBase64Xor(string encryptedBase64){if (string.IsNullOrEmpty(encryptedBase64)) return encryptedBase64;try{byte[] encryptedBytes = Convert.FromBase64String(encryptedBase64);byte[] keyBytes = Encoding.UTF8.GetBytes(secretKey);byte[] decryptedBytes = new byte[encryptedBytes.Length];for (int i = 0; i < encryptedBytes.Length; i++){decryptedBytes[i] = (byte)(encryptedBytes[i] ^ keyBytes[i % keyBytes.Length]);}return Encoding.UTF8.GetString(decryptedBytes);}catch (FormatException e){Debug.LogError($"Error decoding Base64 before XOR decryption: {e.Message}");return null;}catch (Exception e) // General exception for other potential issues{Debug.LogError($"Error during XOR decryption: {e.Message}");return null;}}
}

在SaveLoadManager中应用XOR（结合Base64）:

// ... 在 SaveLoadManager 类中 ...public void SaveGame(PlayerDataAdvanced data)
{// ... (确保目录存在) ...string json = JsonConvert.SerializeObject(data, Formatting.Indented);// 先进行XOR加密，然后将结果进行Base64编码string encryptedData = SimpleXorEncryption.EncryptDecrypt(json); // 这个方法现在返回Base64字符串try{File.WriteAllText(FilePath, encryptedData); // 写入加密并编码后的数据Debug.Log($"Game saved (encrypted/encoded) to {FilePath}");}catch (IOException e) { /* ... 错误处理 ... */ }
}public PlayerDataAdvanced LoadGame()
{if (File.Exists(FilePath)){try{string encryptedData = File.ReadAllText(FilePath); // 读取加密并编码后的数据// 先进行Base64解码，然后XOR解密string json = SimpleXorEncryption.DecryptFromBase64Xor(encryptedData);if (json == null) {Debug.LogError("Failed to decrypt save data.");return null;}PlayerDataAdvanced loadedData = JsonConvert.DeserializeObject<PlayerDataAdvanced>(json);Debug.Log($"Game loaded (decrypted/decoded) from {FilePath}");return loadedData;}catch (IOException e) { /* ... 错误处理 ... */ return null; }catch (JsonException e) { /* ... 错误处理 ... */ return null; }// DecryptFromBase64Xor 内部已包含解码和解密异常处理}else{// ... (文件不存在的处理) ...return null;}
}

重要提示：这里的密钥管理非常关键。硬编码密钥（如示例）非常不安全。在实际项目中，应考虑更安全的密钥存储和管理方法（但这超出了本入门教程的范围）。

5.4 其他安全措施

• 校验和（Checksum）：在保存数据时，计算一个基于数据内容的校验和（如MD5或SHA256哈希值）并一同存储。加载时重新计算校验和并进行比对，如果校验和不匹配，说明数据被篡改过。
• 使用更强的加密库：对于需要更高安全性的场景，应使用成熟的加密库（如.NET的System.Security.Cryptography命名空间下的AES等对称加密算法），并正确管理密钥。

六、实践：实现游戏数据存档与加载

现在，我们将把前面学到的知识整合起来，创建一个简单的GameManager来处理玩家数据的保存和加载。假设我们的游戏需要保存玩家的位置、得分和物品栏（一个字符串列表）。

6.1 定义玩家数据结构 (PlayerData.cs)

using UnityEngine;
using System.Collections.Generic;
using Newtonsoft.Json; // 如果使用Newtonsoft[System.Serializable] // 如果同时需要Unity序列化（比如Inspector）
public class PlayerData
{// 使用JsonProperty明确指定要序列化的字段（推荐用Newtonsoft时这样做）[JsonProperty("position")]public float[] PlayerPosition { get; set; } // Vector3不直接被Newtonsoft很好地处理，拆分成float数组或自定义Converter[JsonProperty("score")]public int Score { get; set; }[JsonProperty("inventory")]public List<string> InventoryItems { get; set; }// 为Vector3提供转换方法public void SetPosition(Vector3 pos){PlayerPosition = new float[3] { pos.x, pos.y, pos.z };}public Vector3 GetPosition(){if (PlayerPosition != null && PlayerPosition.Length == 3){return new Vector3(PlayerPosition[0], PlayerPosition[1], PlayerPosition[2]);}return Vector3.zero; // 默认值或错误处理}// 构造函数，用于创建默认数据或加载失败时使用public PlayerData(){SetPosition(Vector3.zero);Score = 0;InventoryItems = new List<string>();}
}

注意: JsonUtility可以直接序列化Vector3，但Newtonsoft.Json默认可能不会将其序列化为理想的格式（如 {"x":1,"y":2,"z":3}），除非进行额外配置或使用自定义转换器。将Vector3拆分为float[]是一种简单兼容两种序列化器的方法。如果只用JsonUtility，可以直接使用public Vector3 playerPosition;。

6.2 创建存档加载管理器 (SaveLoadManager.cs)

这个管理器将负责调用序列化、加密（可选）和文件IO。我们可以将其设计成一个单例，方便全局访问。

using UnityEngine;
using System.IO;
using Newtonsoft.Json; // 或 using UnityEngine;public class SaveLoadManager : MonoBehaviour
{// --- 单例模式 ---private static SaveLoadManager _instance;public static SaveLoadManager Instance{get{if (_instance == null){// 尝试在场景中查找实例_instance = FindObjectOfType<SaveLoadManager>();if (_instance == null){// 如果找不到，动态创建一个新的GameObject挂载脚本GameObject singletonObject = new GameObject("SaveLoadManager");_instance = singletonObject.AddComponent<SaveLoadManager>();Debug.Log("SaveLoadManager instance created dynamically.");}}return _instance;}}// --- ---public string saveFileName = "PlayerData.sav"; // 使用.sav或其他非.json扩展名，轻微混淆public bool useEncryption = true; // 控制是否启用加密/混淆private string FilePath => Path.Combine(Application.persistentDataPath, saveFileName);void Awake(){// 确保场景中只有一个实例if (_instance != null && _instance != this){Destroy(gameObject);return;}_instance = this;DontDestroyOnLoad(gameObject); // 让管理器在场景切换时不被销毁}public void SaveGameData(PlayerData data){string directoryPath = Path.GetDirectoryName(FilePath);if (!Directory.Exists(directoryPath)){Directory.CreateDirectory(directoryPath);}// 使用Newtonsoft.Json序列化string json = JsonConvert.SerializeObject(data, Formatting.Indented);// 如果用JsonUtility: string json = JsonUtility.ToJson(data, true);string dataToWrite = json;// 如果启用加密if (useEncryption){// 使用之前的 SimpleXorEncryption 或 DataProtection (Base64)// 注意：确保 SimpleXorEncryption 类也存在于项目中dataToWrite = SimpleXorEncryption.EncryptDecrypt(json); // 返回Base64编码的XOR结果// 或者: dataToWrite = DataProtection.EncodeToBase64(json);}try{File.WriteAllText(FilePath, dataToWrite);Debug.Log($"Game data saved to {FilePath}. Encrypted: {useEncryption}");}catch (IOException e){Debug.LogError($"Failed to save data to {FilePath}: {e.Message}");}}public PlayerData LoadGameData(){if (File.Exists(FilePath)){try{string dataRead = File.ReadAllText(FilePath);string json = dataRead;// 如果启用了加密，需要先解密if (useEncryption){json = SimpleXorEncryption.DecryptFromBase64Xor(dataRead);// 或者: json = DataProtection.DecodeFromBase64(dataRead);if (json == null){Debug.LogError("Failed to decrypt/decode save data. Loading default.");return new PlayerData(); // 返回默认数据}}// 使用Newtonsoft.Json反序列化PlayerData loadedData = JsonConvert.DeserializeObject<PlayerData>(json);// 如果用JsonUtility: PlayerData loadedData = JsonUtility.FromJson<PlayerData>(json);if (loadedData == null) { // Json反序列化失败可能返回nullDebug.LogError("Failed to parse JSON data after decryption/decoding. Loading default.");return new PlayerData();}Debug.Log($"Game data loaded from {FilePath}. Encrypted used in file: {useEncryption}");return loadedData;}catch (IOException e){Debug.LogError($"Failed to load data from {FilePath}: {e.Message}");return new PlayerData(); // IO错误，返回默认}catch (JsonException e) // Json反序列化异常{Debug.LogError($"Error parsing JSON data from {FilePath}: {e.Message}. Loading default.");// 可以考虑删除或备份损坏文件// File.Move(FilePath, FilePath + ".corrupted");return new PlayerData();}// 其他潜在异常 (如解密/解码中的异常，已在其方法内处理并返回null)}else{Debug.Log($"Save file not found at {FilePath}. Creating new game data.");return new PlayerData(); // 文件不存在，返回新的默认数据}}// 提供一个删除存档的方法（用于测试或游戏内功能）public void DeleteSaveData(){if (File.Exists(FilePath)){try{File.Delete(FilePath);Debug.Log($"Save file deleted: {FilePath}");}catch (IOException e){Debug.LogError($"Failed to delete save file {FilePath}: {e.Message}");}}else{Debug.LogWarning($"Attempted to delete non-existent save file: {FilePath}");}}
}

6.3 在游戏逻辑中调用存档与加载

现在，其他的游戏脚本（如玩家控制器、物品管理器、游戏状态管理器等）可以通过SaveLoadManager.Instance来调用保存和加载功能。

示例：玩家控制器 (PlayerController.cs)

using UnityEngine;
using System.Collections.Generic; // 需要Listpublic class PlayerController : MonoBehaviour
{public float speed = 5f;public int score = 0; // 假设玩家得分public List<string> inventory = new List<string>(); // 玩家物品栏void Update(){// 简单的移动逻辑 (示例)float moveHorizontal = Input.GetAxis("Horizontal");float moveVertical = Input.GetAxis("Vertical");Vector3 movement = new Vector3(moveHorizontal, 0.0f, moveVertical);transform.Translate(movement * speed * Time.deltaTime, Space.World);// --- 存档与加载触发示例 ---if (Input.GetKeyDown(KeyCode.F5)) // 按F5保存{SavePlayerData();}if (Input.GetKeyDown(KeyCode.F9)) // 按F9加载{LoadPlayerData();}if (Input.GetKeyDown(KeyCode.F12)) // 按F12删除存档 (测试用){SaveLoadManager.Instance.DeleteSaveData();// 可能需要重置当前玩家状态到默认值ResetToDefaultState();Debug.Log("Save data deleted. Player reset to default state.");}}void Start(){// 游戏开始时尝试加载数据LoadPlayerData();}void SavePlayerData(){PlayerData data = new PlayerData();data.SetPosition(transform.position); // 保存当前位置data.Score = this.score;data.InventoryItems = new List<string>(this.inventory); // 创建副本以防意外修改SaveLoadManager.Instance.SaveGameData(data);Debug.Log("Player data saved.");}void LoadPlayerData(){PlayerData loadedData = SaveLoadManager.Instance.LoadGameData();if (loadedData != null){transform.position = loadedData.GetPosition(); // 恢复位置this.score = loadedData.Score;this.inventory = new List<string>(loadedData.InventoryItems); // 恢复物品栏Debug.Log("Player data loaded.");// 可能还需要更新UI等UpdateUI();}else {Debug.Log("No save data found or failed to load. Starting with default state.");// 确保当前状态是默认状态ResetToDefaultState();}}void ResetToDefaultState() {transform.position = Vector3.zero; // Or your defined start positionthis.score = 0;this.inventory.Clear();UpdateUI(); // Update UI to reflect reset state}// 示例：当捡到物品时public void AddItem(string itemName){inventory.Add(itemName);Debug.Log($"Picked up: {itemName}");UpdateUI(); // 更新UI显示}// 示例：当得分时public void AddScore(int points){score += points;Debug.Log($"Score: {score}");UpdateUI(); // 更新UI显示}// 更新UI的示例方法 (需要你有对应的UI元素)void UpdateUI(){// 例如: FindObjectOfType<UIManager>().UpdateScoreText(score);// 例如: FindObjectOfType<UIManager>().UpdateInventoryDisplay(inventory);Debug.Log("UI should be updated here."); // Placeholder}
}

如何使用：

1. 将PlayerData.cs脚本添加到你的项目中。
2. 将SaveLoadManager.cs脚本添加到场景中的一个空GameObject上（或者它会自动创建）。
3. 将PlayerController.cs脚本添加到你的玩家对象上。
4. （可选）根据需要创建SimpleXorEncryption.cs或DataProtection.cs。
5. 运行游戏，按F5保存，移动玩家或修改数据（如模拟捡东西加分），退出再进入或按F9加载，检查状态是否恢复。按F12可删除存档。

七、常见问题与排错 (Common Issues & Troubleshooting)

实现存档系统时可能会遇到一些常见问题：

1. 文件路径错误/权限问题 (IOException)：
   • 原因：尝试写入不允许写入的目录；目标平台（尤其是移动端）对文件访问有特殊限制；persistentDataPath指向的目录不存在（需要手动创建）。
   • 排查：使用Debug.Log(Application.persistentDataPath)打印确切路径；确保在写入前检查并创建目录 (Directory.Exists, Directory.CreateDirectory)；检查应用在目标平台上的读写权限设置。
2. 序列化错误 (SerializationException / JsonException)：
   • 原因：尝试序列化不支持的类型（如JsonUtility不支持字典）；类没有标记[System.Serializable]（对JsonUtility）；数据结构更改后，旧存档无法反序列化为新结构；JSON格式损坏。
   • 排查：仔细检查要序列化的类和字段是否符合所选序列化器的要求；添加版本号到存档数据中，加载时检查版本号，如果版本不匹配则执行数据迁移逻辑或使用默认数据；在LoadGame中添加try-catch块捕获JsonException，并记录错误信息或删除损坏的存档。
3. 数据丢失或不一致：
   • 原因：忘记在修改数据后调用保存；保存时机不当（如在对象销毁后才尝试保存其状态）；加载后没有正确应用数据到游戏对象；多处代码修改同一数据但只有部分被保存。
   • 排查：确保在关键节点（如关卡完成、退出游戏前、重要状态改变后）调用保存；使用单例或服务定位器模式集中管理存档数据的读写；加载数据后，确保所有相关组件的状态都被更新；使用Debug.Log跟踪数据从加载到应用的全过程。
4. 性能问题（存档/加载过慢）：
   • 原因：存档文件过大（保存了不必要的冗余数据，或数据结构效率低下）；频繁地进行完整存档操作；在主线程执行耗时的文件IO或序列化操作。
   • 排查：优化PlayerData结构，只保存必要信息；考虑增量存档（只保存变化的部分，较复杂）；对于大型存档，使用异步文件IO (File.WriteAllTextAsync, File.ReadAllTextAsync) 或将存档操作放到单独的线程或协程中执行，避免阻塞主线程（注意线程安全）。
5. 加密/解密失败：
   • 原因：加密和解密使用的密钥不一致；加密后的数据（尤其是非Base64编码的二进制数据）在存取过程中损坏；Base64字符串格式错误。
   • 排查：确保加密和解密使用完全相同的密钥；推荐将加密后的二进制结果转换为Base64字符串再存储，提高鲁棒性；在解密前添加对输入字符串格式的校验；使用try-catch捕获解密/解码过程中可能出现的FormatException等异常。

八、总结

恭喜你完成了第33天的学习！今天我们深入探讨了Unity中游戏存档与加载的多种技术和实践方法。核心知识点回顾：

1. 存档的重要性：持久化数据是提升玩家体验和留存的关键。
2. PlayerPrefs：适用于存储少量、简单的键值对数据（如设置、最高分），但有类型、结构、安全性和性能限制。
3. JSON序列化：是将复杂对象转换为文本格式（JSON）进行存储的核心技术。
   • JsonUtility：Unity内置，简单易用，适合基础需求，但有局限（不支持字典、多态等）。
   • Newtonsoft.Json：功能强大的第三方库，支持更复杂的数据结构和更精细的控制，是处理复杂存档数据的常用选择。
4. 文件读写 (System.IO)：使用File.WriteAllText和File.ReadAllText将序列化后的JSON字符串写入到Application.persistentDataPath下的文件中，并从中读取。
5. 数据安全初步考量：
   • 明文存储易被篡改。
   • Base64编码：简单混淆，使数据不可直接阅读。
   • 简单XOR加密：需要密钥，比Base64稍安全，但易被破解。
   • 更高级的保护需要校验和及真正的加密算法（如AES）。
6. 实践：我们通过PlayerData类定义数据结构，并创建了一个SaveLoadManager单例来整合序列化、文件IO和（可选的）加密/混淆，实现了保存和加载玩家位置、得分、物品栏的功能。

掌握存档与加载机制是Unity开发者的必备技能。根据你的项目需求选择合适的方法（简单数据用PlayerPrefs，复杂数据用JSON + File IO），并根据安全需求考虑添加适当的保护措施。

在接下来的学习中，我们将继续探索Unity的其他重要模块，如音频管理、场景管理等，敬请期待！

---