using UnityEngine;
using UnityEngine.UI;
using UnityEngine.U2D;

public class AtlasLoader : MonoBehaviour
{
    [SerializeField] private Image[] _images;

    void Start()
    {
        // 从 Resources 文件夹加载图集
        SpriteAtlas atlas = Resources.Load<SpriteAtlas>("UI/MainAtlas");
        if (atlas == null)
        {
            Debug.LogError("图集加载失败，检查路径是否正确");
            return;
        }

        // GetSprite 传入的是打包时的文件名（不含扩展名）
        // Single 模式：直接传文件名，如 "icon_sword"
        // Multiple 模式（Sprite Sheet）：传 "文件名_索引"，如 "icon_sword_0"
        _images[0].sprite = atlas.GetSprite("icon_sword");
        _images[1].sprite = atlas.GetSprite("icon_shield");
        _images[2].sprite = atlas.GetSprite("icon_potion");
    }
}

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.U2D;

public class AtlasFromAB : MonoBehaviour
{
    [SerializeField] private Image _targetImage;

    void Start()
    {
        string bundlePath = Application.streamingAssetsPath + "/AssetBundles/ui_atlas";
        AssetBundle bundle = AssetBundle.LoadFromFile(bundlePath);

        if (bundle == null)
        {
            Debug.LogError("AB 包加载失败");
            return;
        }

        SpriteAtlas atlas = bundle.LoadAsset<SpriteAtlas>("MainAtlas");
        _targetImage.sprite = atlas.GetSprite("icon_sword");

        // 图集资源已提取，可以卸载包体（false = 保留已加载资源）
        bundle.Unload(false);
    }
}

using UnityEngine;
using UnityEngine.U2D;
using System;

// 挂载到场景中持久存在的对象上（如 GameManager）
public class AtlasLateBinding : MonoBehaviour
{
    void OnEnable()
    {
        // 注册图集请求事件
        SpriteAtlasManager.atlasRequested += OnAtlasRequested;
        // 可选：图集注册完成后的回调
        SpriteAtlasManager.atlasRegistered += OnAtlasRegistered;
    }

    void OnDisable()
    {
        SpriteAtlasManager.atlasRequested -= OnAtlasRequested;
        SpriteAtlasManager.atlasRegistered -= OnAtlasRegistered;
    }

    // Unity 找不到图集时触发，atlasName 是图集名称
    private void OnAtlasRequested(string atlasName, Action<SpriteAtlas> callback)
    {
        Debug.Log($"请求图集: {atlasName}");

        // 从 Resources 加载（也可以换成 AB 包加载）
        SpriteAtlas atlas = Resources.Load<SpriteAtlas>(atlasName);

        if (atlas != null)
            callback(atlas); // 把图集交还给 Unity
        else
            Debug.LogError($"找不到图集: {atlasName}");
    }

    private void OnAtlasRegistered(SpriteAtlas atlas)
    {
        Debug.Log($"图集已注册: {atlas.name}");
    }
}

// 必须放在 Editor 文件夹下
using System;
using System.Collections.Generic;
using System.IO;
using UnityEditor;
using UnityEditor.U2D;
using UnityEngine;
using UnityEngine.U2D;
using Object = UnityEngine.Object;

public class SpriteAtlasBuilder
{
    // 需要打包的图片根目录（每个子文件夹对应一个图集）
    private static readonly string SourceRoot = Application.dataPath + "/Art/Sprites/";
    // 图集输出目录
    private static readonly string OutputPath = "Assets/Art/Atlases/";

    [MenuItem("Tools/Build Sprite Atlases")]
    public static void BuildAll()
    {
        if (!Directory.Exists(SourceRoot))
        {
            Debug.LogError($"源目录不存在: {SourceRoot}");
            return;
        }

        Directory.CreateDirectory(OutputPath.Replace("Assets/", Application.dataPath + "/").Replace("Assets", ""));

        var dirs = new DirectoryInfo(SourceRoot).GetDirectories();
        for (int i = 0; i < dirs.Length; i++)
        {
            var dir = dirs[i];
            EditorUtility.DisplayProgressBar("打包图集", $"处理: {dir.Name}", (float)i / dirs.Length);

            string atlasPath = OutputPath + dir.Name + ".spriteatlas";
            SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasPath)
                                ?? CreateAtlas(atlasPath);

            UpdateAtlasContent(atlas, SourceRoot + dir.Name);
        }

        EditorUtility.ClearProgressBar();
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
        Debug.Log("图集打包完成");
    }

    private static SpriteAtlas CreateAtlas(string savePath)
    {
        var atlas = new SpriteAtlas();

        // 基础打包设置
        atlas.SetPackingSettings(new SpriteAtlasPackingSettings
        {
            blockOffset = 1,
            enableRotation = false,    // 禁止旋转，避免 UI 显示异常
            enableTightPacking = false, // 禁止紧密排列，避免图片边缘互相干扰
            padding = 4,
        });

        // 纹理设置
        atlas.SetTextureSettings(new SpriteAtlasTextureSettings
        {
            readable = false,
            generateMipMaps = false,
            sRGB = true,
            filterMode = FilterMode.Bilinear,
        });

        // Android 平台压缩格式
        var androidSettings = atlas.GetPlatformSettings("Android");
        androidSettings.overridden = true;
        androidSettings.maxTextureSize = 2048;
        androidSettings.format = TextureImporterFormat.ASTC_6x6;
        atlas.SetPlatformSettings(androidSettings);

        // iOS 平台压缩格式
        var iosSettings = atlas.GetPlatformSettings("iPhone");
        iosSettings.overridden = true;
        iosSettings.maxTextureSize = 2048;
        iosSettings.format = TextureImporterFormat.PVRTC_RGB4;
        atlas.SetPlatformSettings(iosSettings);

        AssetDatabase.CreateAsset(atlas, savePath);
        return atlas;
    }

    private static void UpdateAtlasContent(SpriteAtlas atlas, string folderPath)
    {
        var existing = new HashSet<Object>(atlas.GetPackables());
        var toAdd = new List<Object>();

        foreach (var file in Directory.GetFiles(folderPath, "*", SearchOption.AllDirectories))
        {
            if (!file.EndsWith(".png") && !file.EndsWith(".jpg")) continue;

            // 转换为相对于 Assets 的路径
            string relativePath = "Assets" + file.Replace(Application.dataPath, "").Replace("\\", "/");
            var obj = AssetDatabase.LoadAssetAtPath<Object>(relativePath);

            if (obj != null && !existing.Contains(obj))
                toAdd.Add(obj);
        }

        if (toAdd.Count > 0)
            atlas.Add(toAdd.ToArray());
    }
}

#if UNITY_EDITOR
using UnityEngine;
using UnityEngine.Profiling;

// 挂到场景中，运行时在 Console 输出当前帧的渲染统计
public class DrawCallMonitor : MonoBehaviour
{
    void Update()
    {
        // 需要在 Editor 的 Stats 面板查看，或通过 Profiler API
        // UnityStats 仅在编辑器下可用
        if (Time.frameCount % 60 == 0) // 每 60 帧输出一次
        {
            Debug.Log($"[渲染统计] 帧: {Time.frameCount} | " +
                      $"已分配内存: {Profiler.GetTotalAllocatedMemoryLong() / 1024 / 1024} MB");
        }
    }
}
#endif

// Editor/AssetBundleBuilder.cs
using UnityEditor;
using System.IO;

public class AssetBundleBuilder
{
    [MenuItem("Tools/Build AssetBundles")]
    public static void BuildAllAB()
    {
        string outputPath = "Assets/StreamingAssets/AssetBundles";
        if (!Directory.Exists(outputPath))
            Directory.CreateDirectory(outputPath);

        // BuildAssetBundleOptions.ChunkBasedCompression 使用 LZ4 压缩
        BuildPipeline.BuildAssetBundles(
            outputPath,
            BuildAssetBundleOptions.ChunkBasedCompression,
            BuildTarget.StandaloneWindows64
        );

        AssetDatabase.Refresh();
        UnityEngine.Debug.Log("AssetBundle 构建完成");
    }
}

// Runtime/AssetBundleManager.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class AssetBundleManager : MonoBehaviour
{
    // 缓存已加载的 AB 包，避免重复加载
    private Dictionary<string, AssetBundle> _loadedBundles = new();
    
    private string _basePath;

    void Awake()
    {
        _basePath = Application.streamingAssetsPath + "/AssetBundles/";
    }

    // 同步加载 AB 包（会阻塞主线程，小包可用）
    public AssetBundle LoadBundle(string bundleName)
    {
        if (_loadedBundles.TryGetValue(bundleName, out var cached))
            return cached;

        // 先加载依赖
        LoadDependencies(bundleName);

        var bundle = AssetBundle.LoadFromFile(_basePath + bundleName);
        if (bundle == null)
        {
            Debug.LogError($"加载 AB 包失败: {bundleName}");
            return null;
        }

        _loadedBundles[bundleName] = bundle;
        return bundle;
    }

    // 加载依赖包（通过 Manifest 自动解析）
    private void LoadDependencies(string bundleName)
    {
        // Manifest 包名与输出目录同名
        var manifestBundle = AssetBundle.LoadFromFile(_basePath + "AssetBundles");
        if (manifestBundle == null) return;

        var manifest = manifestBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        string[] deps = manifest.GetAllDependencies(bundleName);

        foreach (var dep in deps)
        {
            if (!_loadedBundles.ContainsKey(dep))
            {
                var depBundle = AssetBundle.LoadFromFile(_basePath + dep);
                if (depBundle != null)
                    _loadedBundles[dep] = depBundle;
            }
        }

        manifestBundle.Unload(false); // 卸载 Manifest 包，保留已加载资源
    }

    // 异步加载 AB 包（推荐，不阻塞主线程）
    public IEnumerator LoadBundleAsync(string bundleName, System.Action<AssetBundle> onComplete)
    {
        if (_loadedBundles.TryGetValue(bundleName, out var cached))
        {
            onComplete?.Invoke(cached);
            yield break;
        }

        var request = AssetBundle.LoadFromFileAsync(_basePath + bundleName);
        yield return request;

        if (request.assetBundle == null)
        {
            Debug.LogError($"异步加载 AB 包失败: {bundleName}");
            yield break;
        }

        _loadedBundles[bundleName] = request.assetBundle;
        onComplete?.Invoke(request.assetBundle);
    }

    // 从已加载的包中加载具体资源
    public T LoadAsset<T>(string bundleName, string assetName) where T : Object
    {
        var bundle = LoadBundle(bundleName);
        return bundle?.LoadAsset<T>(assetName);
    }

    // 卸载 AB 包
    // unloadAllObjects=true：同时卸载从该包加载的所有资源实例（防内存泄漏）
    // unloadAllObjects=false：只卸载包本身，已加载的资源继续存在
    public void UnloadBundle(string bundleName, bool unloadAllObjects = false)
    {
        if (_loadedBundles.TryGetValue(bundleName, out var bundle))
        {
            bundle.Unload(unloadAllObjects);
            _loadedBundles.Remove(bundleName);
        }
    }

    // 卸载所有包
    public void UnloadAll(bool unloadAllObjects = false)
    {
        foreach (var bundle in _loadedBundles.Values)
            bundle.Unload(unloadAllObjects);
        _loadedBundles.Clear();
    }
}

// 使用 AssetBundleManager 加载预制体并实例化
public class GameLoader : MonoBehaviour
{
    [SerializeField] private AssetBundleManager _abManager;

    IEnumerator Start()
    {
        // 异步加载包
        AssetBundle bundle = null;
        yield return _abManager.LoadBundleAsync("characters", b => bundle = b);

        if (bundle != null)
        {
            // 从包中加载预制体
            var prefab = bundle.LoadAsset<GameObject>("Hero");
            Instantiate(prefab, Vector3.zero, Quaternion.identity);

            // 资源实例化后可以卸载包（unloadAllObjects=false 保留实例）
            _abManager.UnloadBundle("characters", false);
        }
    }
}

// Runtime/AddressablesLoader.cs
using System.Collections;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class AddressablesLoader : MonoBehaviour
{
    // 在 Inspector 中直接引用 Addressable 资源（推荐，类型安全）
    [SerializeField] private AssetReferenceGameObject _heroPrefabRef;

    private AsyncOperationHandle<GameObject> _loadHandle;

    void Start()
    {
        // 方式一：通过 AssetReference（Inspector 拖拽绑定）
        LoadViaAssetReference();

        // 方式二：通过地址字符串
        // LoadViaAddress("Hero");
    }

    // 通过 AssetReference 加载（推荐）
    void LoadViaAssetReference()
    {
        _loadHandle = _heroPrefabRef.LoadAssetAsync<GameObject>();
        _loadHandle.Completed += OnLoadComplete;
    }

    // 通过地址字符串加载
    void LoadViaAddress(string address)
    {
        _loadHandle = Addressables.LoadAssetAsync<GameObject>(address);
        _loadHandle.Completed += OnLoadComplete;
    }

    private void OnLoadComplete(AsyncOperationHandle<GameObject> handle)
    {
        if (handle.Status == AsyncOperationStatus.Succeeded)
        {
            Instantiate(handle.Result, Vector3.zero, Quaternion.identity);
            Debug.Log("资源加载成功");
        }
        else
        {
            Debug.LogError($"资源加载失败: {handle.OperationException}");
        }
    }

    void OnDestroy()
    {
        // 必须释放句柄，否则引用计数不归零，内存泄漏
        if (_loadHandle.IsValid())
            Addressables.Release(_loadHandle);
    }
}

public class AddressablesInstantiator : MonoBehaviour
{
    [SerializeField] private string _address;
    private AsyncOperationHandle<GameObject> _instantiateHandle;

    IEnumerator Start()
    {
        // InstantiateAsync 直接加载并实例化，一步到位
        _instantiateHandle = Addressables.InstantiateAsync(
            _address,
            Vector3.zero,
            Quaternion.identity
        );

        // 等待完成并显示进度
        while (!_instantiateHandle.IsDone)
        {
            Debug.Log($"加载进度: {_instantiateHandle.PercentComplete:P0}");
            yield return null;
        }

        if (_instantiateHandle.Status == AsyncOperationStatus.Succeeded)
            Debug.Log($"实例化成功: {_instantiateHandle.Result.name}");
    }

    void OnDestroy()
    {
        // InstantiateAsync 创建的对象用 ReleaseInstance 释放
        if (_instantiateHandle.IsValid())
            Addressables.ReleaseInstance(_instantiateHandle);
    }
}

public class AddressablesBatchLoader : MonoBehaviour
{
    // 通过 Label 批量加载同类资源
    [SerializeField] private string _label = "Enemies";

    private AsyncOperationHandle<IList<GameObject>> _batchHandle;

    IEnumerator Start()
    {
        _batchHandle = Addressables.LoadAssetsAsync<GameObject>(
            _label,
            obj => Debug.Log($"单个资源加载完成: {obj.name}") // 每个资源加载完的回调
        );

        yield return _batchHandle;

        if (_batchHandle.Status == AsyncOperationStatus.Succeeded)
        {
            foreach (var prefab in _batchHandle.Result)
                Instantiate(prefab);
        }
    }

    void OnDestroy()
    {
        if (_batchHandle.IsValid())
            Addressables.Release(_batchHandle);
    }
}

using UnityEngine.ResourceManagement.ResourceProviders;
using UnityEngine.SceneManagement;

public class AddressablesSceneLoader : MonoBehaviour
{
    [SerializeField] private string _sceneAddress = "Level_01";
    private AsyncOperationHandle<SceneInstance> _sceneHandle;

    public IEnumerator LoadScene()
    {
        _sceneHandle = Addressables.LoadSceneAsync(
            _sceneAddress,
            LoadSceneMode.Additive, // 叠加模式，不卸载当前场景
            activateOnLoad: true
        );

        while (!_sceneHandle.IsDone)
        {
            Debug.Log($"场景加载进度: {_sceneHandle.PercentComplete:P0}");
            yield return null;
        }

        Debug.Log("场景加载完成");
    }

    public IEnumerator UnloadScene()
    {
        if (_sceneHandle.IsValid())
        {
            var unloadHandle = Addressables.UnloadSceneAsync(_sceneHandle);
            yield return unloadHandle;
        }
    }
}

using System.Collections.Generic;
using UnityEngine.AddressableAssets.ResourceLocators;

public class AddressablesUpdater : MonoBehaviour
{
    IEnumerator Start()
    {
        // Step 1：检查 Catalog 是否有更新
        var checkHandle = Addressables.CheckForCatalogUpdates(autoReleaseHandle: false);
        yield return checkHandle;

        if (checkHandle.Status != AsyncOperationStatus.Succeeded)
        {
            Addressables.Release(checkHandle);
            yield break;
        }

        List<string> catalogsToUpdate = checkHandle.Result;
        Addressables.Release(checkHandle);

        if (catalogsToUpdate.Count == 0)
        {
            Debug.Log("无需更新");
            yield break;
        }

        // Step 2：更新 Catalog
        var updateHandle = Addressables.UpdateCatalogs(catalogsToUpdate, autoReleaseHandle: false);
        yield return updateHandle;

        List<IResourceLocator> updatedLocators = updateHandle.Result;
        Addressables.Release(updateHandle);

        // Step 3：下载更新的内容
        foreach (var locator in updatedLocators)
        {
            var sizeHandle = Addressables.GetDownloadSizeAsync(locator.Keys);
            yield return sizeHandle;

            long downloadSize = sizeHandle.Result;
            Addressables.Release(sizeHandle);

            if (downloadSize > 0)
            {
                Debug.Log($"需要下载: {downloadSize / 1024f / 1024f:F2} MB");

                var downloadHandle = Addressables.DownloadDependenciesAsync(locator.Keys);
                yield return downloadHandle;
                Addressables.Release(downloadHandle);
            }
        }

        Debug.Log("更新完成");
    }
}

string variant = SystemInfo.systemMemorySize > 4096 ? "hd" : "sd";

// 加载对应变体的 AB 包
string bundlePath = $"characters/hero.{variant}";
AssetBundle ab = AssetBundle.LoadFromFile(bundlePath);

// 资源名称不变，Unity 自动从当前加载的变体中取
GameObject hero = ab.LoadAsset<GameObject>("Hero");
Instantiate(hero);

// 本地加载
AssetBundle ab = AssetBundle.LoadFromFile(path);
GameObject prefab = ab.LoadAsset<GameObject>("Hero");

// 网络下载（带缓存）
IEnumerator LoadFromCDN(string url, uint version)
{
    using var req = UnityWebRequestAssetBundle.GetAssetBundle(url, version, 0);
    yield return req.SendWebRequest();
    AssetBundle ab = DownloadHandlerAssetBundle.GetContent(req);
    var prefab = ab.LoadAsset<GameObject>("Hero");
    Instantiate(prefab);
    ab.Unload(false);
}

BuildAssetBundles("Assets/AB", BuildAssetBundleOptions.None);              // LZMA
BuildAssetBundles("Assets/AB", BuildAssetBundleOptions.ChunkBasedCompression); // LZ4
BuildAssetBundles("Assets/AB", BuildAssetBundleOptions.UncompressedAssetBundle); // 不压缩

IEnumerator DownloadAndRecompress(string url, string savePath, string cachePath)
{
    // 下载 LZMA 包
    using var req = UnityWebRequestAssetBundle.GetAssetBundle(url);
    yield return req.SendWebRequest();

    // 存到磁盘
    File.WriteAllBytes(savePath, req.downloadHandler.data);

    // 立即转换成 LZ4 存到缓存目录
    var op = AssetBundle.RecompressAssetBundleAsync(
        savePath, cachePath,
        BuildCompression.LZ4,
        0, ThreadPriority.Low
    );
    yield return op;

    // 删掉原始 LZMA 包（可选）
    File.Delete(savePath);

    // 之后加载用 cachePath
}

// 输入数据结构
[System.Serializable]
public struct FrameInput
{
    public int playerId;
    public int frame;
    public Vector2 moveDir;
    public bool firePressed;
}

// 帧同步管理器
public class LockstepManager : MonoBehaviour
{
    public static int CurrentFrame { get; private set; }
    private const float FrameInterval = 0.066f; // ~15帧/秒逻辑帧
    private float _timer;

    // 存储每帧所有玩家的输入
    private Dictionary<int, List<FrameInput>> _frameInputBuffer = new();

    // 本地玩家输入
    private FrameInput _localInput;

    void Update()
    {
        CollectLocalInput();

        _timer += Time.deltaTime;
        if (_timer >= FrameInterval)
        {
            _timer -= FrameInterval;
            TrySendInput();
        }
    }

    void CollectLocalInput()
    {
        _localInput = new FrameInput
        {
            playerId = NetworkManager.LocalPlayerId,
            frame = CurrentFrame,
            moveDir = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical")),
            firePressed = Input.GetButton("Fire1")
        };
    }

    void TrySendInput()
    {
        // 发送本地输入到服务器
        NetworkManager.Send(_localInput);
    }

    // 服务器广播回来后调用
    public void OnReceiveFrameInputs(List<FrameInput> inputs)
    {
        _frameInputBuffer[CurrentFrame] = inputs;
        ExecuteFrame(CurrentFrame, inputs);
        CurrentFrame++;
    }

    void ExecuteFrame(int frame, List<FrameInput> inputs)
    {
        foreach (var input in inputs)
        {
            var player = PlayerManager.GetPlayer(input.playerId);
            player.ApplyInput(input); // 确定性逻辑，不用 Time.deltaTime
        }

        // checksum 校验
        int checksum = ComputeChecksum();
        NetworkManager.SendChecksum(frame, checksum);
    }

    int ComputeChecksum()
    {
        // 简单示例：对所有玩家位置做哈希
        int hash = 0;
        foreach (var player in PlayerManager.AllPlayers)
        {
            hash ^= player.LogicPosition.GetHashCode();
        }
        return hash;
    }
}

// 玩家逻辑（必须确定性，避免浮点误差用定点数）
public class PlayerLogic : MonoBehaviour
{
    public Vector2Int LogicPosition; // 用整数或定点数
    private const int Speed = 5;

    public void ApplyInput(FrameInput input)
    {
        // 确定性移动，不依赖 Time.deltaTime
        LogicPosition += Vector2Int.RoundToInt(input.moveDir * Speed);
        transform.position = new Vector3(LogicPosition.x * 0.01f, 0, LogicPosition.y * 0.01f);
    }
}

// 状态数据结构
[System.Serializable]
public struct PlayerState
{
    public int playerId;
    public Vector3 position;
    public Vector3 velocity;
    public float timestamp;
}

// 服务器端逻辑（Server-side，可用 Mirror/Netcode 等框架）
public class ServerPlayerController : MonoBehaviour
{
    private Rigidbody _rb;
    private float _broadcastInterval = 0.05f; // 20次/秒
    private float _timer;

    void FixedUpdate()
    {
        _timer += Time.fixedDeltaTime;
        if (_timer >= _broadcastInterval)
        {
            _timer = 0;
            BroadcastState();
        }
    }

    // 收到客户端输入
    public void OnReceiveInput(Vector2 moveDir, int playerId)
    {
        // 服务器执行权威逻辑
        Vector3 force = new Vector3(moveDir.x, 0, moveDir.y) * 10f;
        _rb.AddForce(force);
    }

    void BroadcastState()
    {
        var state = new PlayerState
        {
            playerId = GetPlayerId(),
            position = transform.position,
            velocity = _rb.velocity,
            timestamp = Time.time
        };
        NetworkManager.BroadcastToAll(state);
    }
}

// 客户端插值
public class ClientPlayerInterpolation : MonoBehaviour
{
    private PlayerState _from;
    private PlayerState _to;
    private float _lerpT;
    private const float InterpDelay = 0.1f; // 100ms 缓冲

    private Queue<PlayerState> _stateBuffer = new();

    // 收到服务器状态
    public void OnReceiveState(PlayerState state)
    {
        _stateBuffer.Enqueue(state);
    }

    void Update()
    {
        float renderTime = Time.time - InterpDelay;

        // 找到合适的插值区间
        while (_stateBuffer.Count > 1 && _stateBuffer.Peek().timestamp <= renderTime)
        {
            _from = _stateBuffer.Dequeue();
        }

        if (_stateBuffer.Count > 0)
        {
            _to = _stateBuffer.Peek();
            float t = Mathf.InverseLerp(_from.timestamp, _to.timestamp, renderTime);
            transform.position = Vector3.Lerp(_from.position, _to.position, t);
        }
    }
}

// 客户端预测（本地玩家）
public class ClientPrediction : MonoBehaviour
{
    private Vector3 _predictedPos;
    private Rigidbody _rb;

    void Update()
    {
        // 本地立即响应输入
        Vector2 input = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"));
        _rb.AddForce(new Vector3(input.x, 0, input.y) * 10f);

        // 发送输入到服务器
        NetworkManager.SendInput(input);
    }

    // 服务器校正
    public void OnServerCorrection(PlayerState authoritative)
    {
        float posError = Vector3.Distance(transform.position, authoritative.position);
        if (posError > 0.5f)
        {
            // 误差过大，强制修正
            transform.position = authoritative.position;
            _rb.velocity = authoritative.velocity;
        }
        else
        {
            // 平滑修正
            transform.position = Vector3.Lerp(transform.position, authoritative.position, 0.3f);
        }
    }
}

float a = 1.0f / 3.0f;

// x86 FPU (80位精度中间计算): 0.33333334326744...
// ARM NEON (32位严格计算):     0.33333331346511...
// 结果不同！

// 累积误差示例：同样的逻辑跑1000帧
float pos = 0f;
for (int i = 0; i < 1000; i++)
    pos += 0.1f; // 每帧微小误差累积

// 平台A结果: 99.99999...
// 平台B结果: 100.00001...
// 1000帧后两个客户端玩家位置已经不同了

Fixed pos = Fixed.From(0);
Fixed step = Fixed.From(0.1f); // 初始化时转换一次

for (int i = 0; i < 1000; i++)
    pos += step; // 整数加法，任何平台结果都是同一个整数

// 所有平台：raw = 6553600，ToFloat() = 100.0 ✓

using Unity.Netcode;
using UnityEngine;

public class PlayerStats : NetworkBehaviour
{
    // 服务器修改，自动同步到所有客户端
    public NetworkVariable<int> Health = new(100);
    public NetworkVariable<Vector3> Position = new(Vector3.zero);

    public override void OnNetworkSpawn()
    {
        // 监听变化
        Health.OnValueChanged += OnHealthChanged;
    }

    void OnHealthChanged(int oldVal, int newVal)
    {
        // 客户端收到变化后更新 UI
        UIManager.UpdateHealthBar(newVal);
        if (newVal <= 0) PlayDeathEffect();
    }

    // 只有服务器能修改
    public void TakeDamage(int damage)
    {
        if (!IsServer) return;
        Health.Value = Mathf.Max(0, Health.Value - damage);
    }
}

public class InterpolatedTransform : NetworkBehaviour
{
    private struct TransformSnapshot
    {
        public float time;
        public Vector3 position;
        public Quaternion rotation;
    }

    private Queue<TransformSnapshot> _buffer = new();
    private const float BufferDelay = 0.1f; // 100ms 缓冲

    // 服务器广播位置
    [ClientRpc]
    public void UpdateTransformClientRpc(Vector3 pos, Quaternion rot)
    {
        if (IsOwner) return; // 本地玩家不需要插值
        _buffer.Enqueue(new TransformSnapshot
        {
            time = Time.time,
            position = pos,
            rotation = rot
        });
    }

    void Update()
    {
        if (IsOwner || _buffer.Count < 2) return;

        float renderTime = Time.time - BufferDelay;

        // 找到插值区间
        TransformSnapshot from = _buffer.Peek();
        TransformSnapshot to = default;

        foreach (var snap in _buffer)
        {
            if (snap.time <= renderTime) from = snap;
            else { to = snap; break; }
        }

        if (to.time == 0) return;

        float t = Mathf.InverseLerp(from.time, to.time, renderTime);
        transform.position = Vector3.Lerp(from.position, to.position, t);
        transform.rotation = Quaternion.Slerp(from.rotation, to.rotation, t);
    }
}

public class ClientPrediction : NetworkBehaviour
{
    private Rigidbody _rb;
    private Vector3 _serverPosition;
    private bool _hasCorrection;

    void Update()
    {
        if (!IsOwner) return;

        // 1. 本地立即执行输入（预测）
        Vector3 input = new Vector3(
            Input.GetAxisRaw("Horizontal"), 0,
            Input.GetAxisRaw("Vertical")
        );
        _rb.MovePosition(transform.position + input * 5f * Time.deltaTime);

        // 2. 发送输入到服务器
        MoveServerRpc(input);

        // 3. 收到服务器校正后修正
        if (_hasCorrection)
        {
            float error = Vector3.Distance(transform.position, _serverPosition);
            transform.position = error > 1f
                ? _serverPosition                                          // 误差大：强制修正
                : Vector3.Lerp(transform.position, _serverPosition, 0.2f); // 误差小：平滑修正
            _hasCorrection = false;
        }
    }

    [ServerRpc]
    void MoveServerRpc(Vector3 input)
    {
        // 服务器执行权威逻辑
        _rb.MovePosition(transform.position + input * 5f * Time.deltaTime);
        // 广播权威位置给该客户端
        CorrectPositionClientRpc(transform.position);
    }

    [ClientRpc]
    void CorrectPositionClientRpc(Vector3 authoritative)
    {
        if (!IsOwner) return;
        _serverPosition = authoritative;
        _hasCorrection = true;
    }
}

public class CombatEffects : NetworkBehaviour
{
    [SerializeField] private ParticleSystem _hitEffect;
    [SerializeField] private AudioClip _hitSound;

    // 服务器判定命中后，通知所有客户端播放特效
    public void OnHit(Vector3 hitPoint)
    {
        if (!IsServer) return;
        PlayHitEffectClientRpc(hitPoint);
    }

    [ClientRpc]
    void PlayHitEffectClientRpc(Vector3 hitPoint)
    {
        _hitEffect.transform.position = hitPoint;
        _hitEffect.Play();
        AudioSource.PlayClipAtPoint(_hitSound, hitPoint);
    }

    // 客户端请求服务器执行技能
    [ServerRpc(RequireOwnership = true)]
    public void CastSkillServerRpc(int skillId, Vector3 targetPos)
    {
        // 服务器验证并执行
        SkillManager.Execute(skillId, targetPos, OwnerClientId);
    }
}

[AttributeName]          // 标记在类、方法、字段上
public void MyMethod() { }

public class MyNetworkObject : NetworkBehaviour
{
    // [ClientRpc] = 服务器调用，在所有客户端执行
    // 方法名必须以 ClientRpc 结尾
    [ClientRpc]
    public void PlayEffectClientRpc(Vector3 pos)
    {
        // 这段代码在每个客户端上运行
        Instantiate(effectPrefab, pos, Quaternion.identity);
    }

    // [ServerRpc] = 客户端调用，在服务器执行
    // 方法名必须以 ServerRpc 结尾
    [ServerRpc]
    public void RequestFireServerRpc(Vector3 direction)
    {
        // 这段代码只在服务器上运行
        SpawnBullet(direction);
    }
}

// 调用方式
void Update()
{
    if (IsServer)
        PlayEffectClientRpc(transform.position); // 服务器调用，广播到所有客户端

    if (IsOwner)
        RequestFireServerRpc(aimDirection);      // 客户端调用，发送到服务器
}

// 新写法
[Rpc(SendTo.ClientsAndHost)]
public void PlayEffectRpc(Vector3 pos) { }

[Rpc(SendTo.Server)]
public void RequestFireRpc(Vector3 dir) { }

// 旧写法（仍然支持）
[ClientRpc]
public void PlayEffectClientRpc(Vector3 pos) { }

[ServerRpc]
public void RequestFireServerRpc(Vector3 dir) { }