// 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) { }

[System.Flags]
public enum PlayerDirtyFlags : uint
{
    None        = 0,
    Position    = 1 << 0,
    Rotation    = 1 << 1,
    Health      = 1 << 2,
    Mana        = 1 << 3,
    Animation   = 1 << 4,
}

public class PlayerState
{
    public Vector3 Position;
    public float Rotation;
    public int Health;
    public int Mana;
    public int AnimationId;

    private PlayerState _lastSent = new(); // 上次发送的快照
    private PlayerDirtyFlags _dirty;

    // 修改字段时标记脏
    public void SetPosition(Vector3 pos)
    {
        if (Position == pos) return;
        Position = pos;
        _dirty |= PlayerDirtyFlags.Position;
    }

    public void SetHealth(int hp)
    {
        if (Health == hp) return;
        Health = hp;
        _dirty |= PlayerDirtyFlags.Health;
    }

    // 序列化：只写入脏字段
    public byte[] SerializeDelta()
    {
        using var writer = new BinaryWriter(new MemoryStream());

        writer.Write((uint)_dirty); // 先写标记位

        if (_dirty.HasFlag(PlayerDirtyFlags.Position))
        {
            writer.Write(Position.x);
            writer.Write(Position.y);
            writer.Write(Position.z);
        }
        if (_dirty.HasFlag(PlayerDirtyFlags.Health))
            writer.Write(Health);
        if (_dirty.HasFlag(PlayerDirtyFlags.Mana))
            writer.Write(Mana);
        // ... 其他字段

        _dirty = PlayerDirtyFlags.None; // 清除脏标记
        return ((MemoryStream)writer.BaseStream).ToArray();
    }

    // 反序列化：根据标记位读取对应字段
    public void DeserializeDelta(byte[] data)
    {
        using var reader = new BinaryReader(new MemoryStream(data));

        var flags = (PlayerDirtyFlags)reader.ReadUInt32();

        if (flags.HasFlag(PlayerDirtyFlags.Position))
        {
            Position = new Vector3(
                reader.ReadSingle(),
                reader.ReadSingle(),
                reader.ReadSingle()
            );
        }
        if (flags.HasFlag(PlayerDirtyFlags.Health))
            Health = reader.ReadInt32();
        if (flags.HasFlag(PlayerDirtyFlags.Mana))
            Mana = reader.ReadInt32();
    }
}

public class SnapshotDelta
{
    // 完整快照
    public struct WorldSnapshot
    {
        public Dictionary<int, PlayerSnapshot> Players;
        public int Tick;
    }

    public struct PlayerSnapshot
    {
        public Vector3 Position;
        public int Health;
        public int Score;
    }

    private WorldSnapshot _baseline; // 客户端已确认的基准快照

    // 服务器：对比两个快照，生成差量包
    public byte[] GenerateDelta(WorldSnapshot from, WorldSnapshot to)
    {
        using var writer = new BinaryWriter(new MemoryStream());

        writer.Write(to.Tick);

        foreach (var (id, toPlayer) in to.Players)
        {
            // 新增玩家
            if (!from.Players.TryGetValue(id, out var fromPlayer))
            {
                writer.Write((byte)DeltaOp.Add);
                writer.Write(id);
                WriteFullPlayer(writer, toPlayer);
                continue;
            }

            // 对比变化
            PlayerDirtyFlags dirty = PlayerDirtyFlags.None;
            if (fromPlayer.Position != toPlayer.Position) dirty |= PlayerDirtyFlags.Position;
            if (fromPlayer.Health   != toPlayer.Health)   dirty |= PlayerDirtyFlags.Health;
            if (fromPlayer.Score    != toPlayer.Score)    dirty |= PlayerDirtyFlags.Score;

            if (dirty != PlayerDirtyFlags.None)
            {
                writer.Write((byte)DeltaOp.Update);
                writer.Write(id);
                writer.Write((uint)dirty);
                if (dirty.HasFlag(PlayerDirtyFlags.Position)) WriteVector3(writer, toPlayer.Position);
                if (dirty.HasFlag(PlayerDirtyFlags.Health))   writer.Write(toPlayer.Health);
            }
        }

        // 离开的玩家
        foreach (var id in from.Players.Keys)
        {
            if (!to.Players.ContainsKey(id))
            {
                writer.Write((byte)DeltaOp.Remove);
                writer.Write(id);
            }
        }

        return ((MemoryStream)writer.BaseStream).ToArray();
    }

    enum DeltaOp : byte { Add, Update, Remove }
}

public static class PositionCompressor
{
    // 全量：Vector3 = 12字节
    // 压缩后：只发变化量，用short存，约4-6字节

    private const float Precision = 0.01f; // 1cm精度
    private const float MaxDelta = 32767 * Precision; // short最大值对应的距离

    // 发送位置差值而不是绝对值
    public static short[] CompressDelta(Vector3 from, Vector3 to)
    {
        Vector3 delta = to - from;
        return new short[]
        {
            (short)(delta.x / Precision),
            (short)(delta.y / Precision),
            (short)(delta.z / Precision)
        };
        // 3个short = 6字节，比12字节少一半
    }

    public static Vector3 DecompressDelta(Vector3 baseline, short[] delta)
    {
        return baseline + new Vector3(
            delta[0] * Precision,
            delta[1] * Precision,
            delta[2] * Precision
        );
    }
}

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// Simple GET endpoint returning a string
app.MapGet("/", () => "Hello World!");

// GET endpoint with a route parameter
app.MapGet("/products/{id}", (int id) => $"Returning product {id}");

// POST endpoint that accepts a JSON object (Todo item)
app.MapPost("/todoitems", (Todo todo) => 
    Results.Created($"/todoitems/{todo.Id}", todo));

app.Run();

// Data model for the POST example
public record Todo(int Id, string Name, bool IsComplete);

public class MyService
{
    private readonly IHttpClientFactory _httpClientFactory;

    public MyService(IHttpClientFactory httpClientFactory)
    {
        _httpClientFactory = httpClientFactory;
    }

    public async Task<string> GetExternalDataAsync()
    {
        // 1. Create the client
        var client = _httpClientFactory.CreateClient();

        // 2. Make the GET request
        var response = await client.GetAsync("https://api.example.com");

        // 3. Ensure success and read content
        if (response.IsSuccessStatusCode)
        {
            return await response.Content.ReadAsStringAsync();
        }

        return "Error fetching data";
    }
}