// 手动存档系统设计
public class ManualSaveSystem {
    public int maxSlots = 10; // 最大存档槽位数
    
    public void Save(int slotIndex) {
        if (slotIndex < 0 || slotIndex >= maxSlots) {
            ShowError("无效的存档槽位");
            return;
        }
        
        // 收集游戏状态
        var gameState = CollectGameState();
        
        // 序列化
        var saveData = Serialize(gameState);
        
        // 写入文件
        WriteSaveFile(slotIndex, saveData);
        
        // 显示保存成功提示
        ShowSaveConfirmation(slotIndex);
    }
    
    public void Load(int slotIndex) {
        if (!SaveFileExists(slotIndex)) {
            ShowError("存档不存在");
            return;
        }
        
        // 读取文件
        var saveData = ReadSaveFile(slotIndex);
        
        // 反序列化
        var gameState = Deserialize(saveData);
        
        // 恢复游戏状态
        RestoreGameState(gameState);
    }
}

public class AutoSaveSystem {
    private float autoSaveInterval = 300f; // 5 分钟
    private float timeSinceLastSave = 0f;
    
    public void Update() {
        timeSinceLastSave += Time.deltaTime;
        
        // 时间触发
        if (timeSinceLastSave >= autoSaveInterval) {
            PerformAutoSave();
            timeSinceLastSave = 0f;
        }
    }
    
    public void OnCheckpointReached() {
        // 事件触发：到达检查点
        PerformAutoSave();
    }
    
    public void OnQuestCompleted() {
        // 事件触发：完成任务
        PerformAutoSave();
    }
    
    public void OnAreaEntered(string areaName) {
        // 事件触发：进入新区域
        PerformAutoSave();
    }
    
    public void OnGameExit() {
        // 退出触发
        PerformAutoSave();
    }
    
    private void PerformAutoSave() {
        var gameState = CollectGameState();
        var saveData = Serialize(gameState);
        
        // 写入自动存档槽位（通常是槽位 0）
        WriteSaveFile(0, saveData, isAutoSave: true);
        
        // 显示自动存档提示（不打断游戏）
        ShowAutoSaveIndicator();
    }
}

public class CheckpointSystem {
    private Vector3 lastCheckpointPosition;
    private int lastCheckpointId;
    
    public void SetCheckpoint(int checkpointId, Vector3 position) {
        lastCheckpointId = checkpointId;
        lastCheckpointPosition = position;
        
        // 保存最小状态（位置、检查点 ID）
        SaveCheckpointData(checkpointId, position);
        
        // 视觉反馈
        PlayCheckpointActivationEffect(position);
    }
    
    public void OnPlayerDeath() {
        // 从最近检查点重新加载
        RestoreFromCheckpoint(lastCheckpointId, lastCheckpointPosition);
    }
    
    private void RestoreFromCheckpoint(int checkpointId, Vector3 position) {
        // 恢复玩家位置
        player.transform.position = position;
        
        // 恢复敌人状态（可选）
        ResetEnemiesAfterCheckpoint(checkpointId);
        
        // 恢复玩家状态（血量、弹药等）
        RestorePlayerState();
    }
}

{
    "player": {
        "position": {"x": 100.5, "y": 50.2, "z": 0},
        "rotation": {"x": 0, "y": 45, "z": 0},
        "health": 80,
        "max_health": 100,
        "mana": 50,
        "max_mana": 80,
        "experience": 1250,
        "level": 5,
        "stats": {
            "strength": 12,
            "agility": 10,
            "intelligence": 8
        }
    }
}

{
    "progress": {
        "current_level": "level_03",
        "completed_levels": ["level_01", "level_02"],
        "quests": {
            "main_quest_01": "completed",
            "main_quest_02": "in_progress",
            "side_quest_01": "not_started"
        },
        "story_flags": {
            "met_npc_01": true,
            "discovered_secret_area": false,
            "boss_01_defeated": true
        }
    }
}

{
    "world": {
        "npc_states": {
            "npc_01": {
                "location": "village_square",
                "relationship": 75,
                "dialogue_flags": ["greeting_done", "quest_given"]
            },
            "npc_02": {
                "location": "forest",
                "relationship": 30,
                "dialogue_flags": []
            }
        },
        "items": {
            "chest_001_opened": true,
            "chest_002_opened": false,
            "hidden_item_collected": true
        },
        "environment": {
            "time_of_day": 14.5,
            "weather": "sunny",
            "season": "spring"
        }
    }
}

{
    "statistics": {
        "playtime_seconds": 36000,
        "deaths": 12,
        "enemies_killed": 245,
        "items_collected": 89,
        "distance_walked": 15420.5,
        "achievements_unlocked": ["first_blood", "explorer", "collector"]
    }
}

{
    "version": "1.2.0",
    "timestamp": "2026-03-25T10:00:00Z",
    "player": {
        "position": {"x": 100, "y": 50},
        "health": 80
    }
}

[Serializable]
public class SaveData {
    public string version;
    public long timestamp;
    public PlayerData player;
    public WorldData world;
    public StatisticsData statistics;
}

// 序列化
var formatter = new BinaryFormatter();
using (var stream = File.Create(savePath)) {
    formatter.Serialize(stream, saveData);
}

// 反序列化
using (var stream = File.Open(savePath, FileMode.Open)) {
    var saveData = (SaveData)formatter.Deserialize(stream);
}

// save_data.proto
syntax = "proto3";

message SaveData {
    string version = 1;
    int64 timestamp = 2;
    PlayerData player = 3;
    WorldData world = 4;
    StatisticsData statistics = 5;
}

message PlayerData {
    Vector3 position = 1;
    int32 health = 2;
    int32 max_health = 3;
}

message Vector3 {
    float x = 1;
    float y = 2;
    float z = 3;
}

{
    "meta": {
        "version": "1.2.0",
        "game_version": "2.1.0",
        "timestamp": "2026-03-25T10:00:00Z",
        "playtime_seconds": 36000,
        "checksum": "a1b2c3d4e5f6..."
    },
    "player": {
        "position": {
            "x": 100.5,
            "y": 50.2,
            "z": 0
        },
        "rotation": {
            "x": 0,
            "y": 45,
            "z": 0
        },
        "health": 80,
        "max_health": 100,
        "mana": 50,
        "max_mana": 80,
        "experience": 1250,
        "level": 5,
        "stats": {
            "strength": 12,
            "agility": 10,
            "intelligence": 8
        },
        "inventory": [
            {
                "item_id": "sword_001",
                "quantity": 1,
                "durability": 85
            },
            {
                "item_id": "potion_001",
                "quantity": 5
            }
        ],
        "equipment": {
            "weapon": "sword_001",
            "armor": "armor_002",
            "accessory": null
        }
    },
    "progress": {
        "current_level": "level_03",
        "completed_levels": ["level_01", "level_02"],
        "quests": {
            "main_quest_01": {
                "status": "completed",
                "objectives": [
                    {"id": "kill_boss", "completed": true},
                    {"id": "collect_item", "completed": true}
                ]
            },
            "side_quest_01": {
                "status": "in_progress",
                "objectives": [
                    {"id": "talk_to_npc", "completed": true},
                    {"id": "find_item", "completed": false}
                ]
            }
        },
        "story_flags": {
            "met_npc_01": true,
            "discovered_secret_area": false,
            "boss_01_defeated": true,
            "ending_choice": null
        }
    },
    "world": {
        "npc_states": {
            "npc_01": {
                "location": "village_square",
                "relationship": 75,
                "dialogue_flags": ["greeting_done", "quest_given"],
                "schedule_phase": "daytime"
            }
        },
        "items": {
            "chest_001": {"opened": true, "contents": []},
            "chest_002": {"opened": false, "contents": ["potion_001", "gold_100"]},
            "hidden_item_001": {"collected": true}
        },
        "environment": {
            "time_of_day": 14.5,
            "weather": "sunny",
            "season": "spring",
            "day_count": 15
        },
        "enemies": {
            "enemy_001": {"alive": false, "respawn_time": null},
            "enemy_002": {"alive": true, "health": 100}
        }
    },
    "statistics": {
        "deaths": 12,
        "enemies_killed": 245,
        "items_collected": 89,
        "distance_walked": 15420.5,
        "jumps": 1520,
        "attacks_used": 3420
    },
    "settings": {
        "difficulty": "normal",
        "language": "zh-CN",
        "audio_volume": 0.8,
        "music_volume": 0.6
    }
}

using System.IO.Compression;

public static byte[] CompressSaveData(byte[] data) {
    using (var outputStream = new MemoryStream()) {
        using (var gzipStream = new GZipStream(outputStream, CompressionLevel.Optimal)) {
            gzipStream.Write(data, 0, data.Length);
        }
        return outputStream.ToArray();
    }
}

public static byte[] DecompressSaveData(byte[] compressedData) {
    using (var inputStream = new MemoryStream(compressedData)) {
        using (var gzipStream = new GZipStream(inputStream, CompressionMode.Decompress)) {
            using (var outputStream = new MemoryStream()) {
                gzipStream.CopyTo(outputStream);
                return outputStream.ToArray();
            }
        }
    }
}

{
    "meta": {
        "save_version": "1.2.0",
        "game_version": "2.1.0",
        "timestamp": "2026-03-25T10:00:00Z"
    }
}

{
    "player": {
        "health": 100,
        "mana": 50
    }
}

{
    "player": {
        "health": 100,
        "mana": 50,
        "stamina": 80
    }
}

public class SaveMigrator {
    public SaveData Migrate(SaveData oldData, string fromVersion) {
        var version = new Version(fromVersion);
        
        if (version < new Version("1.1.0")) {
            oldData = Migrate_1_0_0_to_1_1_0(oldData);
        }
        
        if (version < new Version("1.2.0")) {
            oldData = Migrate_1_1_0_to_1_2_0(oldData);
        }
        
        return oldData;
    }
    
    private SaveData Migrate_1_0_0_to_1_1_0(SaveData data) {
        // 添加 stamina 字段，使用默认值
        data.player.stamina = 100;
        return data;
    }
    
    private SaveData Migrate_1_1_0_to_1_2_0(SaveData data) {
        // 添加新的属性系统
        data.player.attributes = new Attributes {
            strength = 10,
            agility = 10,
            intelligence = 10
        };
        return data;
    }
}

{
    "player": {
        "health": 100,
        "mana": 50,
        "stamina": 80,
        "deprecated_field": "old_value"
    }
}

{
    "player": {
        "health": 100,
        "mana": 50,
        "stamina": 80
    }
}

private SaveData Migrate_1_2_0_to_2_0_0(SaveData data) {
    // 删除废弃字段（如果存在）
    if (data.player.deprecated_field != null) {
        // 如果有需要，可以转换数据
        data.player.new_field = ConvertOldData(data.player.deprecated_field);
        data.player.deprecated_field = null;
    }
    return data;
}

{
    "player": {
        "position": {"x": 100, "y": 50}
    }
}

{
    "player": {
        "position": {"x": 100, "y": 50, "z": 0}
    }
}

private SaveData Migrate_1_0_0_to_2_0_0(SaveData data) {
    // 将 2D 位置转换为 3D 位置
    var oldPos = data.player.position_2d;
    data.player.position = new Vector3 {
        x = oldPos.x,
        y = oldPos.y,
        z = 0 // 默认 Z 坐标
    };
    data.player.position_2d = null;
    return data;
}

public class SaveBackupSystem {
    private int maxBackups = 3;
    
    public void BackupSaveFile(string savePath) {
        var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
        var backupPath = $"{savePath}.backup_{timestamp}";
        
        File.Copy(savePath, backupPath);
        
        // 清理旧备份
        CleanupOldBackups(savePath);
    }
    
    private void CleanupOldBackups(string savePath) {
        var directory = Path.GetDirectoryName(savePath);
        var fileName = Path.GetFileName(savePath);
        
        var backups = Directory.GetFiles(directory, $"{fileName}.backup_*")
            .OrderByDescending(f => File.GetCreationTime(f))
            .Skip(maxBackups)
            .ToList();
        
        foreach (var backup in backups) {
            File.Delete(backup);
        }
    }
}

using System.Security.Cryptography;

public class SaveEncryption {
    private static readonly byte[] Key = Encoding.UTF8.GetBytes("YourSecretKey1234567890123456"); // 32 字节
    private static readonly byte[] IV = Encoding.UTF8.GetBytes("YourIV12345678"); // 16 字节
    
    public static byte[] Encrypt(byte[] plainData) {
        using (var aes = Aes.Create()) {
            aes.Key = Key;
            aes.IV = IV;
            aes.Mode = CipherMode.CBC;
            aes.Padding = PaddingMode.PKCS7;
            
            using (var encryptor = aes.CreateEncryptor()) {
                return encryptor.TransformFinalBlock(plainData, 0, plainData.Length);
            }
        }
    }
    
    public static byte[] Decrypt(byte[] encryptedData) {
        using (var aes = Aes.Create()) {
            aes.Key = Key;
            aes.IV = IV;
            aes.Mode = CipherMode.CBC;
            aes.Padding = PaddingMode.PKCS7;
            
            using (var decryptor = aes.CreateDecryptor()) {
                return decryptor.TransformFinalBlock(encryptedData, 0, encryptedData.Length);
            }
        }
    }
}

public class SaveChecksum {
    public static string CalculateChecksum(byte[] data) {
        using (var sha256 = SHA256.Create()) {
            var hash = sha256.ComputeHash(data);
            return BitConverter.ToString(hash).Replace("-", "").ToLower();
        }
    }
    
    public static bool VerifyChecksum(byte[] data, string expectedChecksum) {
        var actualChecksum = CalculateChecksum(data);
        return actualChecksum == expectedChecksum;
    }
}

// 使用示例
public class SecureSaveSystem {
    public void Save(SaveData data) {
        var jsonData = JsonUtility.ToJson(data);
        var bytes = Encoding.UTF8.GetBytes(jsonData);
        
        // 计算校验和
        var checksum = SaveChecksum.CalculateChecksum(bytes);
        data.meta.checksum = checksum;
        
        // 重新序列化（包含校验和）
        jsonData = JsonUtility.ToJson(data);
        bytes = Encoding.UTF8.GetBytes(jsonData);
        
        // 加密
        var encrypted = SaveEncryption.Encrypt(bytes);
        
        File.WriteAllBytes(savePath, encrypted);
    }
    
    public SaveData Load() {
        var encrypted = File.ReadAllBytes(savePath);
        
        // 解密
        var bytes = SaveEncryption.Decrypt(encrypted);
        var jsonData = Encoding.UTF8.GetString(bytes);
        var data = JsonUtility.FromJson<SaveData>(jsonData);
        
        // 验证校验和
        var dataWithoutChecksum = RemoveChecksumFromData(data);
        var bytesWithoutChecksum = Encoding.UTF8.GetBytes(JsonUtility.ToJson(dataWithoutChecksum));
        
        if (!SaveChecksum.VerifyChecksum(bytesWithoutChecksum, data.meta.checksum)) {
            throw new SecurityException("存档校验失败，可能已被篡改");
        }
        
        return data;
    }
}

public class ObfuscatedValue {
    private int storedValue;
    private int offset;
    
    public ObfuscatedValue(int actualValue) {
        offset = UnityEngine.Random.Range(-1000, 1000);
        storedValue = actualValue + offset;
    }
    
    public int GetActualValue() {
        return storedValue - offset;
    }
    
    public void SetActualValue(int newValue) {
        offset = UnityEngine.Random.Range(-1000, 1000);
        storedValue = newValue + offset;
    }
}

using Steamworks;

public class SteamCloudSave {
    public static bool SaveToCloud(string filename, byte[] data) {
        // 检查 Steam Cloud 是否启用
        if (!SteamRemoteStorage.IsCloudEnabledForApp()) {
            Debug.LogWarning("Steam Cloud is disabled");
            return false;
        }
        
        // 检查配额
        ulong totalBytes, availableBytes;
        SteamRemoteStorage.GetQuota(out totalBytes, out availableBytes);
        
        if ((ulong)data.Length > availableBytes) {
            Debug.LogError("Not enough Steam Cloud space");
            return false;
        }
        
        // 写入文件
        bool success = SteamRemoteStorage.FileWrite(filename, data, data.Length);
        
        return success;
    }
    
    public static byte[] LoadFromCloud(string filename) {
        if (!SteamRemoteStorage.FileExists(filename)) {
            return null;
        }
        
        int fileSize = SteamRemoteStorage.GetFileSize(filename);
        byte[] data = new byte[fileSize];
        
        int bytesRead = SteamRemoteStorage.FileRead(filename, data, fileSize);
        
        if (bytesRead != fileSize) {
            Debug.LogError("Failed to read from Steam Cloud");
            return null;
        }
        
        return data;
    }
    
    public static void DeleteFromCloud(string filename) {
        if (SteamRemoteStorage.FileExists(filename)) {
            SteamRemoteStorage.FileDelete(filename);
        }
    }
}

public class CloudSaveSync {
    public void SyncSaves() {
        var localSaves = GetLocalSaveFiles();
        var cloudSaves = GetCloudSaveFiles();
        
        foreach (var save in localSaves) {
            var cloudSave = cloudSaves.FirstOrDefault(s => s.Filename == save.Filename);
            
            if (cloudSave == null) {
                // 本地有，云端没有 → 上传
                UploadToCloud(save);
            } else if (save.Timestamp > cloudSave.Timestamp) {
                // 本地更新 → 上传
                UploadToCloud(save);
            } else if (cloudSave.Timestamp > save.Timestamp) {
                // 云端更新 → 下载
                DownloadFromCloud(cloudSave);
            }
        }
        
        foreach (var save in cloudSaves) {
            var localSave = localSaves.FirstOrDefault(s => s.Filename == save.Filename);
            
            if (localSave == null) {
                // 云端有，本地没有 → 下载
                DownloadFromCloud(save);
            }
        }
    }
}

using Epic.OnlineServices;
using Epic.OnlineServices.PlayerDataStorage;

public class EOSCloudSave {
    private PlayerDataStorage _playerDataStorage;
    
    public void Initialize() {
        _playerDataStorage = EOSManager.Instance.GetPlayerDataStorageInterface();
    }
    
    public void SaveToCloud(string filename, byte[] data) {
        var options = new WriteOptions {
            LocalUserId = EOSManager.Instance.GetProductUserId(),
            Filename = filename,
            Data = data,
            OnComplete = (result) => {
                if (result.ResultCode == Result.Success) {
                    Debug.Log("Saved to EOS Cloud");
                } else {
                    Debug.LogError($"Failed to save: {result.ResultCode}");
                }
            }
        };
        
        _playerDataStorage.Write(options);
    }
    
    public void LoadFromCloud(string filename, Action<byte[]> onComplete) {
        var options = new ReadOptions {
            LocalUserId = EOSManager.Instance.GetProductUserId(),
            Filename = filename,
            OnComplete = (result) => {
                if (result.ResultCode == Result.Success) {
                    onComplete(result.Data);
                } else {
                    Debug.LogError($"Failed to load: {result.ResultCode}");
                    onComplete(null);
                }
            }
        };
        
        _playerDataStorage.Read(options);
    }
}

using Amazon.S3;
using Amazon.S3.Model;

public class AWSCloudSave {
    private IAmazonS3 _s3Client;
    private string _bucketName = "game-saves";
    
    public async Task SaveToCloud(string userId, string filename, byte[] data) {
        var key = $"{userId}/{filename}";
        
        var request = new PutObjectRequest {
            BucketName = _bucketName,
            Key = key,
            ContentBody = Convert.ToBase64String(data),
            ContentType = "application/octet-stream"
        };
        
        await _s3Client.PutObjectAsync(request);
    }
    
    public async Task<byte[]> LoadFromCloud(string userId, string filename) {
        var key = $"{userId}/{filename}";
        
        try {
            var response = await _s3Client.GetObjectAsync(_bucketName, key);
            using (var reader = new StreamReader(response.ResponseStream)) {
                var base64 = await reader.ReadToEndAsync();
                return Convert.FromBase64String(base64);
            }
        } catch (AmazonS3Exception e) {
            if (e.ErrorCode == "NoSuchKey") {
                return null;
            }
            throw;
        }
    }
}

using Azure.Storage.Blobs;

public class AzureCloudSave {
    private BlobContainerClient _containerClient;
    
    public async Task SaveToCloud(string userId, string filename, byte[] data) {
        var blobName = $"{userId}/{filename}";
        var blobClient = _containerClient.GetBlobClient(blobName);
        
        using (var stream = new MemoryStream(data)) {
            await blobClient.UploadAsync(stream, overwrite: true);
        }
    }
    
    public async Task<byte[]> LoadFromCloud(string userId, string filename) {
        var blobName = $"{userId}/{filename}";
        var blobClient = _containerClient.GetBlobClient(blobName);
        
        try {
            var response = await blobClient.DownloadAsync();
            using (var memoryStream = new MemoryStream()) {
                await response.Value.Content.CopyToAsync(memoryStream);
                return memoryStream.ToArray();
            }
        } catch (RequestFailedException e) {
            if (e.Status == 404) {
                return null;
            }
            throw;
        }
    }
}

public class CloudSaveConflictUI : MonoBehaviour {
    public void ShowConflict(SaveData localSave, SaveData cloudSave) {
        // 显示两个版本的信息
        localInfo.text = $"本地存档\n时间：{localSave.timestamp}\n游戏时长：{localSave.playtime}";
        cloudInfo.text = $"云端存档\n时间：{cloudSave.timestamp}\n游戏时长：{cloudSave.playtime}";
        
        // 玩家选择
        useLocalButton.onClick.AddListener(() => {
            UseLocalSave(localSave);
        });
        
        useCloudButton.onClick.AddListener(() => {
            UseCloudSave(cloudSave);
        });
    }
    
    private void UseLocalSave(SaveData save) {
        // 上传本地存档到云端
        CloudSave.Upload(save);
        LoadSave(save);
        Close();
    }
    
    private void UseCloudSave(SaveData save) {
        // 下载云端存档到本地
        CloudSave.Download(save);
        LoadSave(save);
        Close();
    }
}

public abstract class PlatformSaveAdapter {
    public abstract byte[] GetPlatformSpecificData();
    public abstract void ApplyPlatformSpecificData(byte[] data);
}

public class PCPlatformAdapter : PlatformSaveAdapter {
    public override byte[] GetPlatformSpecificData() {
        // PC 特定的设置（如键位绑定、分辨率）
        var settings = new PCSettings {
            resolution = Screen.currentResolution,
            keyBindings = InputManager.GetKeyBindings()
        };
        return Serialize(settings);
    }
    
    public override void ApplyPlatformSpecificData(byte[] data) {
        var settings = Deserialize<PCSettings>(data);
        Screen.SetResolution(settings.resolution.width, settings.resolution.height, true);
        InputManager.SetKeyBindings(settings.keyBindings);
    }
}

public class ConsolePlatformAdapter : PlatformSaveAdapter {
    public override byte[] GetPlatformSpecificData() {
        // 主机特定的设置（如手柄配置）
        var settings = new ConsoleSettings {
            controllerSensitivity = InputManager.ControllerSensitivity,
            vibrationEnabled = InputManager.VibrationEnabled
        };
        return Serialize(settings);
    }
    
    public override void ApplyPlatformSpecificData(byte[] data) {
        var settings = Deserialize<ConsoleSettings>(data);
        InputManager.ControllerSensitivity = settings.controllerSensitivity;
        InputManager.VibrationEnabled = settings.vibrationEnabled;
    }
}

public class QuickSaveSystem : MonoBehaviour {
    private void Update() {
        if (Input.GetKeyDown(KeyCode.F5)) {
            QuickSave();
        }
        
        if (Input.GetKeyDown(KeyCode.F9)) {
            QuickLoad();
        }
    }
    
    private void QuickSave() {
        var gameState = CollectGameState();
        SaveSystem.SaveToSlot(999, gameState); // 使用特殊槽位
        ShowNotification("快速存档完成");
    }
    
    private void QuickLoad() {
        if (SaveSystem.SaveExists(999)) {
            var gameState = SaveSystem.LoadFromSlot(999);
            RestoreGameState(gameState);
            ShowNotification("快速读档完成");
        } else {
            ShowNotification("没有快速存档");
        }
    }
}

public class SaveFileManager {
    public void ExportSave(int slotIndex, string exportPath) {
        var saveData = SaveSystem.LoadFromSlot(slotIndex);
        var json = JsonUtility.ToJson(saveData, true);
        File.WriteAllText(exportPath, json);
    }
    
    public void ImportSave(string importPath, int targetSlot) {
        var json = File.ReadAllText(importPath);
        var saveData = JsonUtility.FromJson<SaveData>(json);
        SaveSystem.SaveToSlot(targetSlot, saveData);
    }
    
    public void DeleteSave(int slotIndex) {
        // 显示确认对话框
        if (ShowConfirmation("确定要删除这个存档吗？此操作不可撤销。")) {
            SaveSystem.DeleteSlot(slotIndex);
        }
    }
    
    public void CopySave(int sourceSlot, int targetSlot) {
        var saveData = SaveSystem.LoadFromSlot(sourceSlot);
        SaveSystem.SaveToSlot(targetSlot, saveData);
    }
}

{
    "meta": {
        "save_version": "1.2.0",
        "game_version": "2.1.0",
        "timestamp": "2026-03-25T10:00:00Z",
        "playtime_seconds": 36000,
        "checksum": "a1b2c3d4e5f6..."
    },
    "player": {
        "position": {"x": 100.5, "y": 50.2, "z": 0},
        "rotation": {"x": 0, "y": 45, "z": 0},
        "health": 80,
        "max_health": 100,
        "mana": 50,
        "max_mana": 80,
        "experience": 1250,
        "level": 5,
        "stats": {
            "strength": 12,
            "agility": 10,
            "intelligence": 8
        },
        "inventory": [
            {"item_id": "sword_001", "quantity": 1, "durability": 85},
            {"item_id": "potion_001", "quantity": 5}
        ],
        "equipment": {
            "weapon": "sword_001",
            "armor": "armor_002",
            "accessory": null
        }
    },
    "progress": {
        "current_level": "level_03",
        "completed_levels": ["level_01", "level_02"],
        "quests": {
            "main_quest_01": {
                "status": "completed",
                "objectives": [
                    {"id": "kill_boss", "completed": true},
                    {"id": "collect_item", "completed": true}
                ]
            }
        },
        "story_flags": {
            "met_npc_01": true,
            "discovered_secret_area": false,
            "boss_01_defeated": true
        }
    },
    "world": {
        "npc_states": {
            "npc_01": {
                "location": "village_square",
                "relationship": 75,
                "dialogue_flags": ["greeting_done", "quest_given"]
            }
        },
        "items": {
            "chest_001": {"opened": true, "contents": []},
            "chest_002": {"opened": false, "contents": ["potion_001"]}
        },
        "environment": {
            "time_of_day": 14.5,
            "weather": "sunny",
            "season": "spring",
            "day_count": 15
        }
    },
    "statistics": {
        "deaths": 12,
        "enemies_killed": 245,
        "items_collected": 89,
        "distance_walked": 15420.5
    },
    "settings": {
        "difficulty": "normal",
        "language": "zh-CN",
        "audio_volume": 0.8,
        "music_volume": 0.6
    }
}

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

public class SecureSaveSystem {
    private static readonly byte[] EncryptionKey = GenerateDeviceSpecificKey();
    private static readonly byte[] EncryptionIV = new byte[16] { 
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
        0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 
    };
    
    public static void Save(string filename, SaveData data) {
        try {
            // 1. 序列化
            var json = JsonUtility.ToJson(data);
            var jsonBytes = Encoding.UTF8.GetBytes(json);
            
            // 2. 计算校验和
            var checksum = CalculateChecksum(jsonBytes);
            data.meta.checksum = checksum;
            
            // 3. 重新序列化（包含校验和）
            json = JsonUtility.ToJson(data);
            jsonBytes = Encoding.UTF8.GetBytes(json);
            
            // 4. 压缩
            var compressed = Compress(jsonBytes);
            
            // 5. 加密
            var encrypted = Encrypt(compressed);
            
            // 6. 写入文件
            var path = GetSavePath(filename);
            File.WriteAllBytes(path, encrypted);
            
            Debug.Log($"存档保存成功：{filename}");
        } catch (Exception e) {
            Debug.LogError($"存档保存失败：{e.Message}");
            throw;
        }
    }
    
    public static SaveData Load(string filename) {
        try {
            var path = GetSavePath(filename);
            
            if (!File.Exists(path)) {
                Debug.LogWarning($"存档不存在：{filename}");
                return null;
            }
            
            // 1. 读取文件
            var encrypted = File.ReadAllBytes(path);
            
            // 2. 解密
            var compressed = Decrypt(encrypted);
            
            // 3. 解压缩
            var jsonBytes = Decompress(compressed);
            
            // 4. 反序列化
            var json = Encoding.UTF8.GetString(jsonBytes);
            var data = JsonUtility.FromJson<SaveData>(json);
            
            // 5. 验证校验和
            var dataWithoutChecksum = JsonUtility.FromJson<SaveData>(json);
            dataWithoutChecksum.meta.checksum = "";
            var jsonWithoutChecksum = JsonUtility.ToJson(dataWithoutChecksum);
            var bytesWithoutChecksum = Encoding.UTF8.GetBytes(jsonWithoutChecksum);
            
            var expectedChecksum = data.meta.checksum;
            var actualChecksum = CalculateChecksum(bytesWithoutChecksum);
            
            if (expectedChecksum != actualChecksum) {
                Debug.LogError("存档校验失败，可能已被篡改");
                throw new SecurityException("存档校验失败");
            }
            
            // 6. 版本迁移
            if (data.meta.save_version != GetCurrentSaveVersion()) {
                data = MigrateSave(data);
            }
            
            Debug.Log($"存档加载成功：{filename}");
            return data;
        } catch (Exception e) {
            Debug.LogError($"存档加载失败：{e.Message}");
            throw;
        }
    }
    
    private static byte[] Encrypt(byte[] data) {
        using (var aes = Aes.Create()) {
            aes.Key = EncryptionKey;
            aes.IV = EncryptionIV;
            aes.Mode = CipherMode.CBC;
            aes.Padding = PaddingMode.PKCS7;
            
            using (var encryptor = aes.CreateEncryptor()) {
                return encryptor.TransformFinalBlock(data, 0, data.Length);
            }
        }
    }
    
    private static byte[] Decrypt(byte[] data) {
        using (var aes = Aes.Create()) {
            aes.Key = EncryptionKey;
            aes.IV = EncryptionIV;
            aes.Mode = CipherMode.CBC;
            aes.Padding = PaddingMode.PKCS7;
            
            using (var decryptor = aes.CreateDecryptor()) {
                return decryptor.TransformFinalBlock(data, 0, data.Length);
            }
        }
    }
    
    private static byte[] Compress(byte[] data) {
        using (var output = new MemoryStream()) {
            using (var gzip = new System.IO.Compression.GZipStream(
                output, System.IO.Compression.CompressionLevel.Optimal)) {
                gzip.Write(data, 0, data.Length);
            }
            return output.ToArray();
        }
    }
    
    private static byte[] Decompress(byte[] data) {
        using (var input = new MemoryStream(data)) {
            using (var gzip = new System.IO.Compression.GZipStream(
                input, System.IO.Compression.CompressionMode.Decompress)) {
                using (var output = new MemoryStream()) {
                    gzip.CopyTo(output);
                    return output.ToArray();
                }
            }
        }
    }
    
    private static string CalculateChecksum(byte[] data) {
        using (var sha256 = SHA256.Create()) {
            var hash = sha256.ComputeHash(data);
            return BitConverter.ToString(hash).Replace("-", "").ToLower();
        }
    }
    
    private static byte[] GenerateDeviceSpecificKey() {
        // 使用设备特定信息生成密钥
        var deviceInfo = $"{SystemInfo.deviceUniqueIdentifier}_{Application.productName}";
        using (var sha256 = SHA256.Create()) {
            return sha256.ComputeHash(Encoding.UTF8.GetBytes(deviceInfo));
        }
    }
    
    private static string GetSavePath(string filename) {
        return Path.Combine(Application.persistentDataPath, filename);
    }
    
    private static string GetCurrentSaveVersion() {
        return "1.2.0";
    }
    
    private static SaveData MigrateSave(SaveData data) {
        // 实现版本迁移逻辑
        return new SaveMigrator().Migrate(data, data.meta.save_version);
    }
}