跳至主要內容

11. 存档系统设计

EVOCOSMOS2026/4/14大约 11 分钟

存档系统设计

玩了一下午的游戏，突然断电——如果你没有存档系统，玩家之前所有的心血就全白费了。存档系统就是把游戏的"当前状态"拍一张快照，保存到硬盘上。下次打开游戏时，读出这张快照，游戏就能从上次停下的地方继续。

本章你将学到

  • 存档系统设计原则：什么需要保存、什么不需要
  • JSON 序列化存档（人类可读）
  • 二进制存档（更小更快）
  • 存档数据结构设计
  • 多存档槽位管理
  • 自动存档机制
  • 存档加密与防篡改
  • 云存档实现思路

存档系统设计原则

什么需要保存

不是游戏中的所有东西都需要存档。想象你在拍照——你只需要记录画面中重要的东西，不需要记录每一粒灰尘。

原则总结

  1. 只保存必要数据：能重新计算的就不存
  2. 版本号必须带上：游戏更新后存档格式可能变化，版本号帮你做兼容
  3. 不要保存 Godot 节点引用：节点路径会变化，用路径字符串或 ID 代替
  4. 先序列化再保存：把游戏数据转成 JSON 或二进制，再写入文件

存档数据结构设计

一个好的存档结构应该清晰、可扩展。以下是推荐的层级结构：

JSON 序列化存档

JSON 存档的优点是人类可读——你可以用记事本打开查看和调试。缺点是文件较大、读写较慢。

C#
using Godot;
using System.Text.Json;
using System.Collections.Generic;

public class SaveData
{
    public string Version { get; set; } = "1.0";
    public string SaveTime { get; set; }
    public PlayerData Player { get; set; }
    public WorldData World { get; set; }
    public List<QuestData> Quests { get; set; } = new();
}

public class PlayerData
{
    public float PosX { get; set; }
    public float PosY { get; set; }
    public float PosZ { get; set; }
    public float RotY { get; set; }
    public float Health { get; set; }
    public int Level { get; set; }
    public Dictionary<string, int> Inventory { get; set; } = new();
}

public class WorldData
{
    public string CurrentScene { get; set; }
    public Dictionary<string, bool> ObjectStates { get; set; } = new();
    public List<string> DiscoveredAreas { get; set; } = new();
}

public class QuestData
{
    public string QuestId { get; set; }
    public string State { get; set; }  // "active", "completed", "failed"
    public int Progress { get; set; }
}

public partial class SaveManager : Node
{
    private const string SAVE_DIR = "user://saves/";
    private const string FILE_EXTENSION = ".json";

    public override void _Ready()
    {
        // 确保存档目录存在
        DirAccess.MakeDirRecursiveAbsolute(SAVE_DIR);
    }

    /// <summary>
    /// 保存游戏到指定槽位
    /// </summary>
    public void SaveGame(int slot)
    {
        var saveData = new SaveData
        {
            SaveTime = System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
            Player = CollectPlayerData(),
            World = CollectWorldData(),
            Quests = CollectQuestData()
        };

        string json = JsonSerializer.Serialize(saveData, new JsonSerializerOptions
        {
            WriteIndented = true
        });

        string path = SAVE_DIR + $"save_{slot}{FILE_EXTENSION}";
        var file = FileAccess.Open(path, FileAccess.ModeFlags.Write);
        if (file != null)
        {
            file.StoreString(json);
            file.Close();
            GD.Print($"存档已保存到: {path}");
        }
        else
        {
            GD.PrintErr($"保存失败: {FileAccess.GetOpenError()}");
        }
    }

    /// <summary>
    /// 从指定槽位加载游戏
    /// </summary>
    public SaveData LoadGame(int slot)
    {
        string path = SAVE_DIR + $"save_{slot}{FILE_EXTENSION}";

        if (!FileAccess.FileExists(path))
        {
            GD.PrintErr($"存档不存在: {path}");
            return null;
        }

        var file = FileAccess.Open(path, FileAccess.ModeFlags.Read);
        string json = file.GetAsText();
        file.Close();

        var saveData = JsonSerializer.Deserialize<SaveData>(json);

        GD.Print($"存档已加载: 版本 {saveData.Version}, 时间 {saveData.SaveTime}");
        return saveData;
    }

    /// <summary>
    /// 获取所有存档槽位信息（用于显示存档列表）
    /// </summary>
    public Godot.Collections.Array<Godot.Collections.Dictionary> GetSaveSlots()
    {
        var slots = new Godot.Collections.Array<Godot.Collections.Dictionary>();

        var dir = DirAccess.Open(SAVE_DIR);
        if (dir == null) return slots;

        dir.ListDirBegin();
        string fileName = dir.GetNext();

        while (fileName != "")
        {
            if (fileName.EndsWith(FILE_EXTENSION))
            {
                var file = FileAccess.Open(SAVE_DIR + fileName, FileAccess.ModeFlags.Read);
                string json = file.GetAsText();
                file.Close();

                var data = JsonSerializer.Deserialize<SaveData>(json);
                var info = new Godot.Collections.Dictionary
                {
                    { "file_name", fileName },
                    { "save_time", data.SaveTime },
                    { "level", data.Player.Level },
                    { "scene", data.World.CurrentScene }
                };
                slots.Add(info);
            }
            fileName = dir.GetNext();
        }

        return slots;
    }

    private PlayerData CollectPlayerData()
    {
        var player = GetTree().GetFirstNodeInGroup("player") as CharacterBody3D;
        if (player == null) return new PlayerData();

        return new PlayerData
        {
            PosX = player.GlobalPosition.X,
            PosY = player.GlobalPosition.Y,
            PosZ = player.GlobalPosition.Z,
            RotY = player.Rotation.Y,
            Health = (float)player.Get("health"),
            Level = (int)player.Get("level"),
            // 背包数据从 Inventory 组件收集
            Inventory = new Dictionary<string, int>
            {
                { "sword_iron", 1 },
                { "potion_health", 5 }
            }
        };
    }

    private WorldData CollectWorldData()
    {
        return new WorldData
        {
            CurrentScene = GetTree().CurrentScene.SceneFilePath,
            ObjectStates = new Dictionary<string, bool>
            {
                { "chest_room1", true },
                { "door_boss", false }
            }
        };
    }

    private List<QuestData> CollectQuestData()
    {
        return new List<QuestData>
        {
            new QuestData { QuestId = "main_01", State = "completed", Progress = 100 },
            new QuestData { QuestId = "side_herbs", State = "active", Progress = 3 }
        };
    }
}

二进制存档

二进制存档的优点是文件更小、读写更快、不易被玩家直接修改。适合正式发布的游戏。

C#
using Godot;
using System.Collections.Generic;

public partial class BinarySaveManager : Node
{
    private const string SAVE_DIR = "user://saves/";

    public void SaveBinary(int slot, Dictionary<string, Variant> data)
    {
        string path = SAVE_DIR + $"save_{slot}.dat";
        var file = FileAccess.Open(path, FileAccess.ModeFlags.Write);

        if (file == null)
        {
            GD.PrintErr("无法创建存档文件");
            return;
        }

        // 写入版本号
        file.StoreString("SAVE_V1");

        // 写入时间戳
        file.Store64((ulong)Time.GetTicksMsec());

        // 使用 Godot 内置的二进制序列化
        // 把 Dictionary 转为字节数组
        var packed = new Godot.Collections.Dictionary(data);
        var bytes = VarToBytes(packed);
        file.Store64((ulong)bytes.Length);  // 先存数据长度
        file.StoreBuffer(bytes);

        file.Close();
        GD.Print($"二进制存档已保存: {path}");
    }

    public Godot.Collections.Dictionary LoadBinary(int slot)
    {
        string path = SAVE_DIR + $"save_{slot}.dat";

        if (!FileAccess.FileExists(path)) return null;

        var file = FileAccess.Open(path, FileAccess.ModeFlags.Read);
        string version = file.GetLine();
        ulong timestamp = file.Get64();
        ulong dataLength = file.Get64();
        byte[] bytes = file.GetBuffer(dataLength);
        file.Close();

        var data = (Godot.Collections.Dictionary)BytesToVar(bytes);
        GD.Print($"二进制存档已加载, 版本: {version}");
        return data;
    }

    // 辅助方法
    private byte[] VarToBytes(Godot.Collections.Dictionary dict)
    {
        var streams = new Godot.Collections.Array { dict };
        return Godot.Json.Stringify(dict).ToUtf8Buffer();
    }

    private Variant BytesToVar(byte[] bytes)
    {
        string json = bytes.GetStringFromUtf8();
        var parsed = Godot.Json.ParseString(json);
        return parsed;
    }
}

多存档槽位管理

让玩家可以在多个存档之间切换，就像游戏机上的多个存档位。

C#
using Godot;
using System.Linq;

public partial class SlotManager : Control
{
    private const int MAX_SLOTS = 10;
    private SaveManager _saveManager;

    public override void _Ready()
    {
        _saveManager = GetNode<SaveManager>("/root/SaveManager");
        RefreshSlotList();
    }

    /// <summary>
    /// 刷新存档列表 UI
    /// </summary>
    public void RefreshSlotList()
    {
        var slots = _saveManager.GetSaveSlots();
        var container = GetNode<VBoxContainer>("SlotContainer");

        // 清空现有显示
        foreach (var child in container.GetChildren())
            child.QueueFree();

        // 显示已存在的存档
        foreach (var slotInfo in slots)
        {
            var button = new Button();
            button.Text = $"存档: {slotInfo["save_time"]} - 等级 {slotInfo["level"]}";
            string fileName = (string)slotInfo["file_name"];
            button.Pressed += () => OnSlotSelected(fileName);
            container.AddChild(button);
        }

        // 显示空槽位
        int usedSlots = slots.Count;
        for (int i = usedSlots; i < MAX_SLOTS; i++)
        {
            var button = new Button();
            button.Text = $"空槽位 {i + 1}";
            int slotIndex = i + 1;
            button.Pressed += () => OnNewSlot(slotIndex);
            container.AddChild(button);
        }
    }

    private void OnSlotSelected(string fileName)
    {
        GD.Print($"选择了存档: {fileName}");
        // 加载存档...
    }

    private void OnNewSlot(int slot)
    {
        _saveManager.SaveGame(slot);
        RefreshSlotList();
    }
}

自动存档机制

自动存档防止玩家忘记手动保存而丢失进度。通常在以下时机触发自动存档：

  • 进入新场景时
  • 完成重要任务时
  • 每隔 N 分钟定时保存
  • 玩家打开菜单时
C#
using Godot;

public partial class AutoSave : Node
{
    [Export] public float AutoSaveInterval { get; set; } = 300.0f; // 5分钟
    [Export] public int AutoSaveSlot { get; set; } = 0; // 槽位0为自动存档

    private double _timer;
    private SaveManager _saveManager;

    public override void _Ready()
    {
        _saveManager = GetNode<SaveManager>("/root/SaveManager");

        // 监听场景切换
        GetTree().TreeChanged += OnSceneChanged;
    }

    public override void _Process(double delta)
    {
        _timer += delta;
        if (_timer >= AutoSaveInterval)
        {
            _timer = 0;
            PerformAutoSave();
        }
    }

    private void PerformAutoSave()
    {
        GD.Print("正在自动存档...");
        _saveManager.SaveGame(AutoSaveSlot);
        GD.Print("自动存档完成");
    }

    private void OnSceneChanged()
    {
        // 场景切换时自动存档
        PerformAutoSave();
    }
}

存档加密与防篡改

如果你想防止玩家修改存档（比如改金币数量），可以对存档数据进行加密和签名。

C#
using Godot;
using System.Text.Json;

public partial class SecureSaveManager : Node
{
    // 使用 FileAccess 加密存储（Godot 内置）
    private const string ENCRYPTION_KEY = "YourSecretKey123!";

    public void SaveEncrypted(int slot, object data)
    {
        string path = $"user://saves/secure_{slot}.enc";
        string json = JsonSerializer.Serialize(data);

        var file = FileAccess.OpenEncryptedWithPass(
            path, FileAccess.ModeFlags.Write, ENCRYPTION_KEY);

        if (file != null)
        {
            file.StoreString(json);
            file.Close();

            // 额外写入校验文件（哈希值）
            string hash = ComputeHash(json);
            var hashFile = FileAccess.Open(
                $"user://saves/secure_{slot}.hash", FileAccess.ModeFlags.Write);
            hashFile?.StoreString(hash);
            hashFile?.Close();

            GD.Print("加密存档已保存");
        }
    }

    public string LoadEncrypted(int slot)
    {
        string path = $"user://saves/secure_{slot}.enc";

        var file = FileAccess.OpenEncryptedWithPass(
            path, FileAccess.ModeFlags.Read, ENCRYPTION_KEY);

        if (file != null)
        {
            string json = file.GetAsText();
            file.Close();

            // 验证哈希
            string hashPath = $"user://saves/secure_{slot}.hash";
            if (FileAccess.FileExists(hashPath))
            {
                var hashFile = FileAccess.Open(hashPath, FileAccess.ModeFlags.Read);
                string savedHash = hashFile.GetAsText();
                hashFile.Close();

                string currentHash = ComputeHash(json);
                if (savedHash != currentHash)
                {
                    GD.PrintErr("存档校验失败！存档可能被篡改。");
                    return null;
                }
            }

            GD.Print("加密存档已加载并验证通过");
            return json;
        }

        return null;
    }

    private string ComputeHash(string input)
    {
        // 简单的哈希计算（生产环境建议用 SHA256）
        var bytes = input.ToUtf8Buffer();
        ulong hash = 5381;
        foreach (byte b in bytes)
        {
            hash = ((hash << 5) + hash) + b;
        }
        return hash.ToString();
    }
}

防篡改的局限性

客户端加密只能防"君子"不能防"小人"。真正的安全需要服务端验证。如果你的游戏有在线功能，关键数据（金币、装备）应该以服务端为准。本地存档的加密主要是防止普通玩家用记事本改数字。

云存档思路

云存档就是把存档文件上传到远程服务器。基本流程：

实现要点：

  1. 用户身份认证（登录系统）
  2. 存档上传/下载的 HTTP 接口
  3. 冲突解决策略（本地 vs 云端，谁的更新？以时间戳为准）
  4. 离线支持（先存本地，联网后同步）

本章小结

方案优点缺点适用场景
JSON 存档人类可读，调试方便文件较大，易被修改开发阶段、小型游戏
二进制存档文件小，读写快不可直接阅读正式发布
加密存档防篡改增加复杂度竞技游戏、在线游戏
云存档跨设备同步需要服务器在线游戏

相关章节

最近更新:
贡献者: bobokaka
EVOCOSMOS
Copyright © 2026 EVOCOSMOS