第12章状态同步策略

2026年4月25日 · 游戏开发

12.1 状态快照同步（Snapshot Interpolation）

状态快照同步是现代多人游戏中最常用的同步技术，它通过定期发送完整游戏状态快照来保持客户端一致性。

12.1.1 快照系统架构

设计思路与原理

状态快照同步是多人游戏最常用的同步方式，服务器定期广播游戏世界的完整状态，客户端根据快照更新显示。

核心概念：

快照：某一时刻游戏世界的完整状态
序列号：用于识别和排序快照
时间戳：服务器生成快照的时间
插值延迟：客户端延迟渲染以获得平滑效果

同步流程：

服务器以固定频率（如20Hz）生成快照
快照包含所有可同步对象的状态
服务器广播快照给所有客户端
客户端接收并缓存多个快照
客户端插值渲染平滑显示

核心实现要点

StateSnapshot：存储单个时刻的所有状态
SnapshotBuffer：客户端快照缓存和插值
EntityState：单个实体的可同步状态
序列号管理：处理丢包和乱序到达

使用说明与最佳 practices

适用场景：大部分多人游戏，特别是FPS、MOBA
注意事项：
1. 快照频率要平衡带宽和实时性
2. 只同步变化的数据减少带宽
3. 客户端要做预测减少延迟感
性能考虑：使用Delta压缩减少传输量
扩展建议：可添加优先级同步、LOD同步等

using Godot;
using System;
using System.Collections.Generic;

namespace GameFramework.Network.Sync
{
    /// <summary>
    /// 状态快照
    /// 存储某一时刻的完整游戏状态
    /// </summary>
    public class StateSnapshot
    {
        /// <summary>
        /// 快照时间戳（服务器时间）
        /// </summary>
        public double Timestamp { get; set; }

        /// <summary>
        /// 快照序列号
        /// </summary>
        public uint SequenceNumber { get; set; }

        /// <summary>
        /// 实体状态列表
        /// </summary>
        public Dictionary<int, EntityState> EntityStates { get; set; }

        /// <summary>
        /// 游戏全局状态
        /// </summary>
        public GameGlobalState GlobalState { get; set; }

        public StateSnapshot()
        {
            EntityStates = new Dictionary<int, EntityState>();
            Timestamp = 0;
            SequenceNumber = 0;
        }

        /// <summary>
        /// 获取实体状态
        /// </summary>
        public EntityState GetEntityState(int entityId)
        {
            if (EntityStates.TryGetValue(entityId, out var state))
            {
                return state;
            }
            return null;
        }

        /// <summary>
        /// 添加实体状态
        /// </summary>
        public void AddEntityState(int entityId, EntityState state)
        {
            EntityStates[entityId] = state;
        }
    }

    /// <summary>
    /// 实体状态
    /// 单个游戏实体的状态数据
    /// </summary>
    [Serializable]
    public class EntityState
    {
        /// <summary>
        /// 实体唯一ID
        /// </summary>
        public int EntityId { get; set; }

        /// <summary>
        /// 实体类型
        /// </summary>
        public EntityType Type { get; set; }

        /// <summary>
        /// 位置
        /// </summary>
        public Vector3 Position { get; set; }

        /// <summary>
        /// 旋转（四元数）
        /// </summary>
        public Quaternion Rotation { get; set; }

        /// <summary>
        /// 缩放
        /// </summary>
        public Vector3 Scale { get; set; }

        /// <summary>
        /// 速度
        /// </summary>
        public Vector3 Velocity { get; set; }

        /// <summary>
        /// 实体特定数据（JSON序列化）
        /// </summary>
        public string CustomData { get; set; }

        /// <summary>
        /// 状态有效标记
        /// </summary>
        public bool IsValid { get; set; } = true;

        /// <summary>
        /// 插值两个状态
        /// </summary>
        public static EntityState Interpolate(EntityState from, EntityState to, float t)
        {
            return new EntityState
            {
                EntityId = from.EntityId,
                Type = from.Type,
                Position = from.Position.Lerp(to.Position, t),
                Rotation = from.Position.Lerp(to.Rotation, t),
                Scale = from.Scale.Lerp(to.Scale, t),
                Velocity = from.Velocity.Lerp(to.Velocity, t),
                IsValid = true
            };
        }
    }

    /// <summary>
    /// 游戏全局状态
    /// </summary>
    [Serializable]
    public class GameGlobalState
    {
        /// <summary>
        /// 游戏时间
        /// </summary>
        public double GameTime { get; set; }

        /// <summary>
        /// 游戏阶段
        /// </summary>
        public GamePhase Phase { get; set; }

        /// <summary>
        /// 分数
        /// </summary>
        public Dictionary<int, int> Scores { get; set; }
    }

    /// <summary>
    /// 实体类型枚举
    /// </summary>
    public enum EntityType
    {
        Player,
        Enemy,
        Projectile,
        Item,
        Obstacle
    }

    /// <summary>
    /// 游戏阶段
    /// </summary>
    public enum GamePhase
    {
        Waiting,
        Preparing,
        Playing,
        Ending
    }

    /// <summary>
    /// 快照系统管理器
    /// 负责快照的生成、存储、同步和插值
    /// </summary>
    public partial class SnapshotSystem : Node
    {
        // 服务器端配置
        [Export]
        public int ServerTickRate { get; set; } = 20; // 每秒20个快照

        [Export]
        public int SnapshotBufferSize { get; set; } = 128; // 存储128个历史快照

        // 客户端配置
        [Export]
        public float InterpolationDelay { get; set; } = 0.1f; // 100ms插值延迟

        [Export]
        public int MaxInterpolationWindow { get; set; } = 10; // 最大10个快照

        // 快照存储（服务器：发送历史，客户端：接收缓冲）
        private Dictionary<uint, StateSnapshot> _snapshotHistory = new();
        private Queue<StateSnapshot> _receivedSnapshots = new();
        private uint _nextSequenceNumber = 1;

        // 插值状态
        private StateSnapshot _lastSnapshot;
        private StateSnapshot _targetSnapshot;
        private float _interpolationAlpha = 0f;

        // 统计
        public int SnapshotsSent { get; private set; }
        public int SnapshotsReceived { get; private set; }
        public float AverageSnapshotSize { get; private set; }

        public override void _Ready()
        {
            if (Multiplayer.IsServer())
            {
                // 服务器：启动快照生成定时器
                var timer = new Timer();
                timer.WaitTime = 1.0 / ServerTickRate;
                timer.Timeout += OnServerTick;
                timer.Autostart = true;
                AddChild(timer);
            }
        }

        /// <summary>
        /// 服务器定时生成快照
        /// </summary>
        private void OnServerTick()
        {
            var snapshot = CaptureGameState();
            StoreSnapshot(snapshot);
            BroadcastSnapshot(snapshot);
        }

        /// <summary>
        /// 捕获当前游戏状态
        /// </summary>
        private StateSnapshot CaptureGameState()
        {
            var snapshot = new StateSnapshot
            {
                Timestamp = Time.GetTicksMsec() / 1000.0,
                SequenceNumber = _nextSequenceNumber++
            };

            // 收集所有可同步实体的状态
            var syncables = GetTree().GetNodesInGroup("syncable");
            foreach (var node in syncables)
            {
                if (node is ISyncableEntity entity)
                {
                    var state = entity.CaptureState();
                    snapshot.AddEntityState(entity.EntityId, state);
                }
            }

            // 捕获全局状态
            snapshot.GlobalState = CaptureGlobalState();

            return snapshot;
        }

        /// <summary>
        /// 存储快照到历史
        /// </summary>
        private void StoreSnapshot(StateSnapshot snapshot)
        {
            _snapshotHistory[snapshot.SequenceNumber] = snapshot;

            // 清理旧快照
            while (_snapshotHistory.Count > SnapshotBufferSize)
            {
                uint oldestSequence = uint.MaxValue;
                foreach (var seq in _snapshotHistory.Keys)
                {
                    if (seq < oldestSequence)
                        oldestSequence = seq;
                }
                _snapshotHistory.Remove(oldestSequence);
            }
        }

        /// <summary>
        /// 广播快照到所有客户端
        /// </summary>
        private void BroadcastSnapshot(StateSnapshot snapshot)
        {
            byte[] data = SerializeSnapshot(snapshot);

            // 压缩数据
            data = CompressSnapshot(data);

            // 发送到所有客户端
            Rpc(MethodName.ReceiveSnapshot, data, snapshot.SequenceNumber, snapshot.Timestamp);

            SnapshotsSent++;
            AverageSnapshotSize = (AverageSnapshotSize * (SnapshotsSent - 1) + data.Length) / SnapshotsSent;
        }

        /// <summary>
        /// 客户端接收快照
        /// </summary>
        [Rpc(MultiplayerApi.RpcMode.Authority, TransferMode = MultiplayerPeer.TransferMode.UnreliableOrdered)]
        private void ReceiveSnapshot(byte[] data, uint sequenceNumber, double serverTime)
        {
            // 解压缩
            data = DecompressSnapshot(data);

            // 反序列化
            var snapshot = DeserializeSnapshot(data);
            snapshot.SequenceNumber = sequenceNumber;
            snapshot.Timestamp = serverTime;

            // 添加到接收队列
            _receivedSnapshots.Enqueue(snapshot);

            // 限制队列大小
            while (_receivedSnapshots.Count > MaxInterpolationWindow * 2)
            {
                _receivedSnapshots.Dequeue();
            }

            SnapshotsReceived++;
        }

        public override void _Process(double delta)
        {
            if (!Multiplayer.IsServer())
            {
                // 客户端：执行插值
                ProcessInterpolation((float)delta);
            }
        }

        /// <summary>
        /// 处理状态插值
        /// </summary>
        private void ProcessInterpolation(float delta)
        {
            // 确保有足够的快照进行插值
            if (_receivedSnapshots.Count < 2)
                return;

            // 获取插值时间点
            double renderTime = Time.GetTicksMsec() / 1000.0 - InterpolationDelay;

            // 找到包围renderTime的两个快照
            StateSnapshot fromSnapshot = null;
            StateSnapshot toSnapshot = null;

            var snapshotArray = _receivedSnapshots.ToArray();
            for (int i = 0; i < snapshotArray.Length - 1; i++)
            {
                if (snapshotArray[i].Timestamp <= renderTime &&
                    snapshotArray[i + 1].Timestamp > renderTime)
                {
                    fromSnapshot = snapshotArray[i];
                    toSnapshot = snapshotArray[i + 1];
                    break;
                }
            }

            if (fromSnapshot == null || toSnapshot == null)
                return;

            // 计算插值系数
            float t = (float)((renderTime - fromSnapshot.Timestamp) /
                (toSnapshot.Timestamp - fromSnapshot.Timestamp));
            t = Mathf.Clamp(t, 0f, 1f);

            // 插值所有实体状态
            foreach (var entityId in toSnapshot.EntityStates.Keys)
            {
                var fromState = fromSnapshot.GetEntityState(entityId);
                var toState = toSnapshot.GetEntityState(entityId);

                if (fromState != null && toState != null)
                {
                    var interpolatedState = EntityState.Interpolate(fromState, toState, t);
                    ApplyEntityState(entityId, interpolatedState);
                }
            }
        }

        /// <summary>
        /// 应用实体状态到游戏对象
        /// </summary>
        private void ApplyEntityState(int entityId, EntityState state)
        {
            // 查找或创建实体
            var entity = FindEntity(entityId);
            if (entity != null)
            {
                entity.ApplyState(state);
            }
        }

        /// <summary>
        /// 查找实体
        /// </summary>
        private ISyncableEntity FindEntity(int entityId)
        {
            var entities = GetTree().GetNodesInGroup("syncable");
            foreach (var node in entities)
            {
                if (node is ISyncableEntity entity && entity.EntityId == entityId)
                {
                    return entity;
                }
            }
            return null;
        }

        /// <summary>
        /// 序列化快照
        /// </summary>
        private byte[] SerializeSnapshot(StateSnapshot snapshot)
        {
            // 使用JSON序列化（实际项目中可使用Protobuf或MessagePack）
            var json = new JsonSerializer();
            return System.Text.Encoding.UTF8.GetBytes(json.Serialize(snapshot));
        }

        /// <summary>
        /// 反序列化快照
        /// </summary>
        private StateSnapshot DeserializeSnapshot(byte[] data)
        {
            var json = new JsonSerializer();
            string jsonStr = System.Text.Encoding.UTF8.GetString(data);
            return (StateSnapshot)json.Deserialize(jsonStr);
        }

        /// <summary>
        /// 压缩快照数据
        /// </summary>
        private byte[] CompressSnapshot(byte[] data)
        {
            // 简化示例，实际使用压缩算法
            return data;
        }

        /// <summary>
        /// 解压缩快照数据
        /// </summary>
        private byte[] DecompressSnapshot(byte[] data)
        {
            return data;
        }

        /// <summary>
        /// 捕获全局状态
        /// </summary>
        private GameGlobalState CaptureGlobalState()
        {
            return new GameGlobalState
            {
                GameTime = Time.GetTicksMsec() / 1000.0,
                Phase = GamePhase.Playing,
                Scores = new Dictionary<int, int>()
            };
        }
    }

    /// <summary>
    /// 可同步实体接口
    /// </summary>
    public interface ISyncableEntity
    {
        int EntityId { get; }
        EntityState CaptureState();
        void ApplyState(EntityState state);
    }
}

12.1.2 快照插值原理

插值流程图：

客户端时间轴：
  快照A (t=0)              当前渲染时间              快照B (t=100ms)
     │                           │                        │
     └──────────────┬────────────┘                        │
                    │                                      │
              插值位置 (t=50ms)
                    │
              插值系数 α = 0.5
                    │
         状态 = A + (B - A) × α

关键实现细节：

/// <summary>
/// 状态插值器
/// 负责平滑的状态过渡
/// </summary>
public partial class StateInterpolator : Node
{
    // 插值配置
    [Export]
    public InterpolationMode Mode { get; set; } = InterpolationMode.Linear;

    [Export]
    public float SmoothingFactor { get; set; } = 0.1f;

    // 缓存的实体状态
    private Dictionary<int, InterpolationState> _interpolationStates = new();

    /// <summary>
    /// 执行状态插值
    /// </summary>
    public void InterpolateState(int entityId, EntityState newState, float deltaTime)
    {
        if (!_interpolationStates.TryGetValue(entityId, out var interpState))
        {
            // 首次状态
            _interpolationStates[entityId] = new InterpolationState
            {
                CurrentState = newState,
                TargetState = newState,
                VelocityEstimate = Vector3.Zero
            };
            return;
        }

        // 更新目标状态
        interpState.PreviousTarget = interpState.TargetState;
        interpState.TargetState = newState;

        // 估计速度
        if (interpState.PreviousTarget != null)
        {
            interpState.VelocityEstimate =
                (newState.Position - interpState.PreviousTarget.Position) / deltaTime;
        }

        // 根据模式插值
        switch (Mode)
        {
            case InterpolationMode.Linear:
                interpState.CurrentState = LinearInterpolate(
                    interpState.CurrentState, newState, SmoothingFactor);
                break;

            case InterpolationMode.Cubic:
                interpState.CurrentState = CubicInterpolate(
                    interpState.CurrentState, newState,
                    interpState.VelocityEstimate, deltaTime);
                break;

            case InterpolationMode.Exponential:
                interpState.CurrentState = ExponentialInterpolate(
                    interpState.CurrentState, newState, SmoothingFactor);
                break;
        }

        _interpolationStates[entityId] = interpState;
    }

    /// <summary>
    /// 线性插值
    /// </summary>
    private EntityState LinearInterpolate(EntityState current, EntityState target, float t)
    {
        return EntityState.Interpolate(current, target, t);
    }

    /// <summary>
    /// 三次样条插值（更平滑）
    /// </summary>
    private EntityState CubicInterpolate(EntityState current, EntityState target,
        Vector3 velocityEstimate, float deltaTime)
    {
        // 使用Hermite样条插值
        float t = SmoothingFactor;
        float t2 = t * t;
        float t3 = t2 * t;

        // Hermite基函数
        float h0 = 2 * t3 - 3 * t2 + 1;
        float h1 = -2 * t3 + 3 * t2;
        float h2 = t3 - 2 * t2 + t;
        float h3 = t3 - t2;

        // 插值位置
        Vector3 position = current.Position * h0 +
                          target.Position * h1 +
                          velocityEstimate * h2 * deltaTime +
                          velocityEstimate * h3 * deltaTime;

        var result = new EntityState
        {
            EntityId = current.EntityId,
            Position = position,
            Rotation = current.Rotation.Slerp(target.Rotation, t),
            Velocity = target.Velocity
        };

        return result;
    }

    /// <summary>
    /// 指数平滑插值
    /// </summary>
    private EntityState ExponentialInterpolate(EntityState current, EntityState target, float alpha)
    {
        // 指数平滑：新值 = 旧值 × (1-α) + 目标 × α
        float oneMinusAlpha = 1f - alpha;

        return new EntityState
        {
            EntityId = current.EntityId,
            Position = current.Position * oneMinusAlpha + target.Position * alpha,
            Rotation = current.Rotation.Slerp(target.Rotation, alpha),
            Velocity = current.Velocity * oneMinusAlpha + target.Velocity * alpha
        };
    }

    /// <summary>
    /// 插值模式
    /// </summary>
    public enum InterpolationMode
    {
        Linear,      // 线性插值（最快）
        Cubic,       // 三次样条（最平滑）
        Exponential  // 指数平滑（自适应）
    }

    /// <summary>
    /// 插值状态数据结构
    /// </summary>
    private struct InterpolationState
    {
        public EntityState CurrentState;
        public EntityState TargetState;
        public EntityState PreviousTarget;
        public Vector3 VelocityEstimate;
    }
}

12.2 增量更新与 Delta Compression

12.2.1 Delta压缩原理

Delta压缩通过只发送状态变化部分来大幅减少带宽消耗。

using Godot;
using System;
using System.Collections.Generic;

namespace GameFramework.Network.Sync
{
    /// <summary>
    /// Delta压缩器
    /// 实现增量更新和数据压缩
    /// </summary>
    public class DeltaCompressor
    {
        // 上一个发送的状态（按对等体）
        private Dictionary<int, StateSnapshot> _lastSentStates = new();

        // 压缩配置
        public float PositionThreshold { get; set; } = 0.01f;
        public float RotationThreshold { get; set; } = 0.01f;
        public float VelocityThreshold { get; set; } = 0.1f;

        /// <summary>
        /// 压缩快照
        /// 只包含与上次相比有变化的实体
        /// </summary>
        public DeltaSnapshot Compress(StateSnapshot current, int peerId)
        {
            var delta = new DeltaSnapshot
            {
                BaseSequenceNumber = 0,
                Timestamp = current.Timestamp,
                ChangedEntities = new List<int>(),
                ChangedStates = new Dictionary<int, EntityState>()
            };

            // 获取上次发送的状态
            StateSnapshot lastState = null;
            _lastSentStates.TryGetValue(peerId, out lastState);

            foreach (var kvp in current.EntityStates)
            {
                int entityId = kvp.Key;
                var currentEntityState = kvp.Value;

                bool needsUpdate = false;

                if (lastState == null)
                {
                    // 首次发送，全部包含
                    needsUpdate = true;
                }
                else
                {
                    // 比较与上次的变化
                    var lastEntityState = lastState.GetEntityState(entityId);
                    if (lastEntityState == null)
                    {
                        // 新实体
                        needsUpdate = true;
                    }
                    else
                    {
                        // 检查变化是否超过阈值
                        needsUpdate = HasSignificantChange(lastEntityState, currentEntityState);
                    }
                }

                if (needsUpdate)
                {
                    delta.ChangedEntities.Add(entityId);
                    delta.ChangedStates[entityId] = currentEntityState;
                }
            }

            // 更新记录
            _lastSentStates[peerId] = current;

            // 记录删除的实体
            if (lastState != null)
            {
                foreach (var entityId in lastState.EntityStates.Keys)
                {
                    if (!current.EntityStates.ContainsKey(entityId))
                    {
                        delta.RemovedEntities.Add(entityId);
                    }
                }
            }

            return delta;
        }

        /// <summary>
        /// 解压缩快照
        /// </summary>
        public StateSnapshot Decompress(DeltaSnapshot delta, StateSnapshot baseSnapshot)
        {
            var result = new StateSnapshot
            {
                Timestamp = delta.Timestamp,
                SequenceNumber = delta.SequenceNumber
            };

            if (baseSnapshot != null)
            {
                // 复制基础状态
                foreach (var kvp in baseSnapshot.EntityStates)
                {
                    if (!delta.RemovedEntities.Contains(kvp.Key))
                    {
                        result.AddEntityState(kvp.Key, kvp.Value);
                    }
                }
            }

            // 应用增量更新
            foreach (var entityId in delta.ChangedEntities)
            {
                if (delta.ChangedStates.TryGetValue(entityId, out var state))
                {
                    result.AddEntityState(entityId, state);
                }
            }

            return result;
        }

        /// <summary>
        /// 检查是否有显著变化
        /// </summary>
        private bool HasSignificantChange(EntityState last, EntityState current)
        {
            // 位置变化
            if (last.Position.DistanceSquaredTo(current.Position) > PositionThreshold * PositionThreshold)
                return true;

            // 旋转变化（使用四元数点积）
            float rotationDot = Math.Abs(last.Rotation.Dot(current.Rotation));
            if (rotationDot < 1f - RotationThreshold)
                return true;

            // 速度变化
            if (last.Velocity.DistanceSquaredTo(current.Velocity) > VelocityThreshold * VelocityThreshold)
                return true;

            return false;
        }

        /// <summary>
        /// 清理过期的状态记录
        /// </summary>
        public void Cleanup(TimeSpan maxAge)
        {
            // 可以在这里清理长时间未更新的对等体记录
        }
    }

    /// <summary>
    /// 增量快照结构
    /// </summary>
    public class DeltaSnapshot
    {
        /// <summary>
        /// 基础快照序列号（用于重建完整状态）
        /// </summary>
        public uint BaseSequenceNumber { get; set; }

        /// <summary>
        /// 当前快照序列号
        /// </summary>
        public uint SequenceNumber { get; set; }

        /// <summary>
        /// 时间戳
        /// </summary>
        public double Timestamp { get; set; }

        /// <summary>
        /// 变化的实体ID列表
        /// </summary>
        public List<int> ChangedEntities { get; set; } = new();

        /// <summary>
        /// 变化的实体状态
        /// </summary>
        public Dictionary<int, EntityState> ChangedStates { get; set; } = new();

        /// <summary>
        /// 已删除的实体ID
        /// </summary>
        public List<int> RemovedEntities { get; set; } = new();
    }
}

12.2.2 位级压缩技术

设计思路与原理

位级压缩进一步减少数据传输量，通过精确控制每个比特的使用，相比字节级压缩可节省大量带宽。

压缩技术：

布尔压缩：1比特存储布尔值（而非1字节）
范围限制整数：根据值范围选择最小比特数
浮点数量化：降低浮点数精度（如用16位代替32位）
字典编码：用索引代替重复字符串

常用优化：

Position：浮点坐标量化为16位整数（毫米精度）
Rotation：四元数量化为8位或16位
Health：根据最大值选择比特数（如100血量只需7位）
Flag组合：多个布尔值打包到一个字节

核心实现要点

BitWriter：按位写入数据流
BitReader：按位读取数据流
量化函数：浮点数与整数之间的转换
数据对齐：处理非字节对齐的边界

使用说明与最佳 practices

适用场景：带宽受限的移动网络、大规模多人游戏
注意事项：
1. 精度损失要在可接受范围内
2. 复杂压缩要考虑CPU开销
3. 保留未使用比特位便于扩展
性能考虑：使用位运算提高速度
扩展建议：可添加Huffman编码、字典压缩等

using Godot;
using System;
using System.IO;

namespace GameFramework.Network.Sync
{
    /// <summary>
    /// 位级数据写入器
    /// 实现紧凑的二进制序列化
    /// </summary>
    public class BitWriter
    {
        private MemoryStream _stream;
        private byte _currentByte;
        private int _bitPosition;

        public BitWriter()
        {
            _stream = new MemoryStream();
            _currentByte = 0;
            _bitPosition = 0;
        }

        /// <summary>
        /// 写入布尔值（1位）
        /// </summary>
        public void WriteBool(bool value)
        {
            WriteBits(value ? 1u : 0u, 1);
        }

        /// <summary>
        /// 写入无符号整数（指定位数）
        /// </summary>
        public void WriteBits(uint value, int bitCount)
        {
            for (int i = bitCount - 1; i >= 0; i--)
            {
                bool bit = (value & (1u << i)) != 0;
                WriteBit(bit);
            }
        }

        /// <summary>
        /// 写入压缩的浮点数
        /// </summary>
        public void WriteCompressedFloat(float value, float min, float max, int bitCount)
        {
            // 将float映射到整数范围
            float normalized = (value - min) / (max - min);
            normalized = Mathf.Clamp(normalized, 0f, 1f);
            uint intValue = (uint)(normalized * ((1u << bitCount) - 1));
            WriteBits(intValue, bitCount);
        }

        /// <summary>
        /// 写入压缩的Vector3
        /// </summary>
        public void WriteCompressedVector3(Vector3 vector, float min, float max, int bitsPerComponent)
        {
            WriteCompressedFloat(vector.X, min, max, bitsPerComponent);
            WriteCompressedFloat(vector.Y, min, max, bitsPerComponent);
            WriteCompressedFloat(vector.Z, min, max, bitsPerComponent);
        }

        /// <summary>
        /// 写入单个位
        /// </summary>
        private void WriteBit(bool bit)
        {
            if (bit)
            {
                _currentByte |= (byte)(1 << (7 - _bitPosition));
            }

            _bitPosition++;

            if (_bitPosition >= 8)
            {
                _stream.WriteByte(_currentByte);
                _currentByte = 0;
                _bitPosition = 0;
            }
        }

        /// <summary>
        /// 完成写入并返回数据
        /// </summary>
        public byte[] ToArray()
        {
            // 写入剩余的位
            if (_bitPosition > 0)
            {
                _stream.WriteByte(_currentByte);
            }

            return _stream.ToArray();
        }

        /// <summary>
        /// 获取已写入的位数
        /// </summary>
        public int BitsWritten => (int)(_stream.Length * 8 + _bitPosition);
    }

    /// <summary>
    /// 位级数据读取器
    /// </summary>
    public class BitReader
    {
        private byte[] _data;
        private int _bytePosition;
        private int _bitPosition;

        public BitReader(byte[] data)
        {
            _data = data;
            _bytePosition = 0;
            _bitPosition = 0;
        }

        /// <summary>
        /// 读取布尔值
        /// </summary>
        public bool ReadBool()
        {
            return ReadBits(1) != 0;
        }

        /// <summary>
        /// 读取无符号整数
        /// </summary>
        public uint ReadBits(int bitCount)
        {
            uint result = 0;
            for (int i = 0; i < bitCount; i++)
            {
                result = (result << 1) | (ReadBit() ? 1u : 0u);
            }
            return result;
        }

        /// <summary>
        /// 读取压缩的浮点数
        /// </summary>
        public float ReadCompressedFloat(float min, float max, int bitCount)
        {
            uint intValue = ReadBits(bitCount);
            float normalized = intValue / (float)((1u << bitCount) - 1);
            return min + normalized * (max - min);
        }

        /// <summary>
        /// 读取压缩的Vector3
        /// </summary>
        public Vector3 ReadCompressedVector3(float min, float max, int bitsPerComponent)
        {
            return new Vector3(
                ReadCompressedFloat(min, max, bitsPerComponent),
                ReadCompressedFloat(min, max, bitsPerComponent),
                ReadCompressedFloat(min, max, bitsPerComponent)
            );
        }

        /// <summary>
        /// 读取单个位
        /// </summary>
        private bool ReadBit()
        {
            if (_bytePosition >= _data.Length)
                return false;

            bool bit = (_data[_bytePosition] & (1 << (7 - _bitPosition))) != 0;

            _bitPosition++;
            if (_bitPosition >= 8)
            {
                _bitPosition = 0;
                _bytePosition++;
            }

            return bit;
        }
    }
}

12.3 带宽优化技巧

12.3.1 优先级和LOD同步

using Godot;
using System;
using System.Collections.Generic;

namespace GameFramework.Network.Sync
{
    /// <summary>
    /// 带宽优化管理器
    /// 实现基于距离和优先级的同步策略
    /// </summary>
    public partial class BandwidthOptimizer : Node
    {
        // 同步级别配置
        [Export]
        public float NearDistance { get; set; } = 10f;

        [Export]
        public float MediumDistance { get; set; } = 30f;

        [Export]
        public float FarDistance { get; set; } = 100f;

        // 带宽预算（字节/秒）
        [Export]
        public float BandwidthBudget { get; set; } = 50000f;

        // 当前带宽使用
        private float _currentBandwidthUsage = 0f;

        // 实体优先级
        private Dictionary<int, float> _entityPriorities = new();

        /// <summary>
        /// 计算实体的同步优先级
        /// </summary>
        public float CalculatePriority(ISyncableEntity entity, Vector3 observerPosition)
        {
            if (entity is Node3D node3d)
            {
                float distance = node3d.GlobalPosition.DistanceTo(observerPosition);

                // 距离越近优先级越高
                float distancePriority = 1f - Mathf.Clamp(distance / FarDistance, 0f, 1f);

                // 实体类型优先级
                float typePriority = GetTypePriority(entity);

                // 移动速度优先级（快速移动需要更频繁同步）
                float movementPriority = entity.GetVelocity().Length() / 10f;
                movementPriority = Mathf.Min(movementPriority, 1f);

                // 事件优先级（如果有重要事件发生）
                float eventPriority = entity.HasImportantEvent() ? 1f : 0f;

                // 综合优先级计算
                float priority = distancePriority * 0.4f +
                               typePriority * 0.3f +
                               movementPriority * 0.2f +
                               eventPriority * 0.1f;

                return priority;
            }

            return 0.5f;
        }

        /// <summary>
        /// 根据优先级获取同步级别
        /// </summary>
        public SyncLevel GetSyncLevel(float priority)
        {
            if (priority >= 0.8f)
                return SyncLevel.Full;      // 完整同步：60Hz
            else if (priority >= 0.6f)
                return SyncLevel.High;      // 高频率：30Hz
            else if (priority >= 0.4f)
                return SyncLevel.Medium;    // 中频率：20Hz
            else if (priority >= 0.2f)
                return SyncLevel.Low;       // 低频率：10Hz
            else
                return SyncLevel.Minimal;   // 最小化：5Hz或按需
        }

        /// <summary>
        /// 获取类型的基础优先级
        /// </summary>
        private float GetTypePriority(ISyncableEntity entity)
        {
            switch (entity.Type)
            {
                case EntityType.Player:
                    return 1.0f;    // 玩家最高优先级
                case EntityType.Projectile:
                    return 0.9f;    // 投射物需要精确
                case EntityType.Enemy:
                    return 0.7f;
                case EntityType.Item:
                    return 0.5f;
                case EntityType.Obstacle:
                    return 0.2f;    // 静态障碍物最低
                default:
                    return 0.5f;
            }
        }

        /// <summary>
        /// 获取同步级别对应的频率
        /// </summary>
        public float GetSyncRate(SyncLevel level)
        {
            switch (level)
            {
                case SyncLevel.Full:    return 60f;
                case SyncLevel.High:    return 30f;
                case SyncLevel.Medium:  return 20f;
                case SyncLevel.Low:     return 10f;
                case SyncLevel.Minimal: return 5f;
                default: return 20f;
            }
        }

        /// <summary>
        /// 分配带宽给实体
        /// </summary>
        public Dictionary<int, SyncAllocation> AllocateBandwidth(
            List<ISyncableEntity> entities, Vector3 observerPosition)
        {
            var allocations = new Dictionary<int, SyncAllocation>();

            // 计算所有实体的优先级
            var priorities = new List<(ISyncableEntity entity, float priority)>();
            foreach (var entity in entities)
            {
                float priority = CalculatePriority(entity, observerPosition);
                priorities.Add((entity, priority));
            }

            // 按优先级排序
            priorities.Sort((a, b) => b.priority.CompareTo(a.priority));

            // 分配带宽
            float remainingBandwidth = BandwidthBudget;
            foreach (var (entity, priority) in priorities)
            {
                var level = GetSyncLevel(priority);
                float estimatedSize = EstimateEntitySize(entity, level);
                float rate = GetSyncRate(level);

                float bandwidthNeeded = estimatedSize * rate;

                if (bandwidthNeeded <= remainingBandwidth)
                {
                    allocations[entity.EntityId] = new SyncAllocation
                    {
                        Level = level,
                        Rate = rate,
                        EstimatedBandwidth = bandwidthNeeded
                    };
                    remainingBandwidth -= bandwidthNeeded;
                }
                else
                {
                    // 降低级别或跳过
                    allocations[entity.EntityId] = new SyncAllocation
                    {
                        Level = SyncLevel.Minimal,
                        Rate = 5f,
                        EstimatedBandwidth = estimatedSize * 5f
                    };
                }
            }

            return allocations;
        }

        /// <summary>
        /// 估算实体同步大小
        /// </summary>
        private float EstimateEntitySize(ISyncableEntity entity, SyncLevel level)
        {
            // 基础大小
            float baseSize = 20f; // 包头和ID

            switch (level)
            {
                case SyncLevel.Full:
                    // 完整状态：位置、旋转、速度、动画、自定义数据
                    return baseSize + 50f;

                case SyncLevel.High:
                    // 位置、旋转、速度
                    return baseSize + 30f;

                case SyncLevel.Medium:
                    // 位置和旋转
                    return baseSize + 20f;

                case SyncLevel.Low:
                    // 仅位置
                    return baseSize + 12f;

                case SyncLevel.Minimal:
                    // 仅位置，低频，可能只有delta
                    return baseSize + 6f;

                default:
                    return baseSize + 20f;
            }
        }
    }

    /// <summary>
    /// 同步级别
    /// </summary>
    public enum SyncLevel
    {
        Full,       // 完整同步
        High,       // 高频同步
        Medium,     // 中频同步
        Low,        // 低频同步
        Minimal     // 最小同步
    }

    /// <summary>
    /// 同步分配
    /// </summary>
    public struct SyncAllocation
    {
        public SyncLevel Level;
        public float Rate;
        public float EstimatedBandwidth;
    }

    /// <summary>
    /// 扩展同步实体接口
    /// </summary>
    public interface ISyncableEntity
    {
        int EntityId { get; }
        EntityType Type { get; }
        EntityState CaptureState();
        void ApplyState(EntityState state);
        Vector3 GetVelocity();
        bool HasImportantEvent();
    }
}

12.3.2 预测性生成和销毁

using Godot;
using System;
using System.Collections.Generic;

namespace GameFramework.Network.Sync
{
    /// <summary>
    /// 预测性实体管理器
    /// 在客户端预测实体的生成和销毁
    /// </summary>
    public partial class PredictiveEntityManager : Node
    {
        // 预测配置
        [Export]
        public float PredictionTime { get; set; } = 0.5f; // 预测500ms后的状态

        // 客户端预测生成的实体
        private Dictionary<int, PredictedEntity> _predictedEntities = new();

        // 实体工厂
        private EntityFactory _factory;

        /// <summary>
        /// 预测实体生成
        /// 在收到服务器确认前就显示实体
        /// </summary>
        public void PredictEntitySpawn(int entityId, EntityType type, Vector3 predictedPosition)
        {
            // 创建预测实体
            var entity = _factory.CreateEntity(type);
            if (entity is Node3D node3d)
            {
                node3d.GlobalPosition = predictedPosition;
            }

            var predicted = new PredictedEntity
            {
                EntityId = entityId,
                Instance = entity,
                PredictedPosition = predictedPosition,
                SpawnTime = Time.GetTicksMsec() / 1000.0,
                IsConfirmed = false
            };

            _predictedEntities[entityId] = predicted;

            // 添加视觉效果区分预测和确认状态
            SetPredictionVisual(predicted, true);
        }

        /// <summary>
        /// 确认预测实体
        /// </summary>
        public void ConfirmEntitySpawn(int entityId, Vector3 actualPosition)
        {
            if (!_predictedEntities.TryGetValue(entityId, out var predicted))
            {
                // 服务器生成了我们没有预测的实体
                GD.Print($"收到未预测的实体: {entityId}");
                return;
            }

            predicted.IsConfirmed = true;

            // 如果预测位置与实际位置偏差较大，进行修正
            float error = predicted.PredictedPosition.DistanceTo(actualPosition);
            if (error > 1.0f)
            {
                GD.Print($"实体 {entityId} 预测误差: {error:F2}m");
                SmoothCorrectPosition(predicted, actualPosition);
            }

            // 移除预测视觉效果
            SetPredictionVisual(predicted, false);

            _predictedEntities[entityId] = predicted;
        }

        /// <summary>
        /// 预测实体销毁
        /// </summary>
        public void PredictEntityDestroy(int entityId)
        {
            if (_predictedEntities.TryGetValue(entityId, out var predicted))
            {
                // 标记为预测销毁
                predicted.IsPredictedDestroyed = true;
                predicted.PredictedDestroyTime = Time.GetTicksMsec() / 1000.0;

                // 可以添加淡出效果
                if (predicted.Instance is Node node)
                {
                    FadeOutEntity(node);
                }

                _predictedEntities[entityId] = predicted;
            }
        }

        /// <summary>
        /// 确认实体销毁
        /// </summary>
        public void ConfirmEntityDestroy(int entityId)
        {
            if (_predictedEntities.TryGetValue(entityId, out var predicted))
            {
                // 真正销毁实体
                if (predicted.Instance is Node node)
                {
                    node.QueueFree();
                }

                _predictedEntities.Remove(entityId);
            }
        }

        /// <summary>
        /// 取消预测（如果预测错误）
        /// </summary>
        public void RevertPrediction(int entityId)
        {
            if (_predictedEntities.TryGetValue(entityId, out var predicted))
            {
                if (!predicted.IsConfirmed)
                {
                    // 删除预测创建的实体
                    if (predicted.Instance is Node node)
                    {
                        node.QueueFree();
                    }

                    _predictedEntities.Remove(entityId);
                    GD.Print($"预测失败，已回滚实体: {entityId}");
                }
            }
        }

        /// <summary>
        /// 平滑修正位置
        /// </summary>
        private void SmoothCorrectPosition(PredictedEntity predicted, Vector3 targetPosition)
        {
            if (predicted.Instance is Node3D node3d)
            {
                // 使用Tween平滑过渡
                var tween = CreateTween();
                tween.SetEase(Tween.EaseType.Out);
                tween.SetTrans(Tween.TransitionType.Quad);
                tween.TweenProperty(node3d, "global_position", targetPosition, 0.2f);
            }
        }

        /// <summary>
        /// 设置预测视觉效果
        /// </summary>
        private void SetPredictionVisual(PredictedEntity predicted, bool isPrediction)
        {
            if (predicted.Instance is Node3D node3d)
            {
                // 可以添加半透明、轮廓等效果
                // 示例：设置透明度
                // ...
            }
        }

        /// <summary>
        /// 实体淡出效果
        /// </summary>
        private void FadeOutEntity(Node node)
        {
            // 实现淡出逻辑
            GD.Print($"实体淡出: {node.Name}");
        }

        /// <summary>
        /// 清理过期预测
        /// </summary>
        public void CleanupOldPredictions(float maxAge)
        {
            double currentTime = Time.GetTicksMsec() / 1000.0;

            foreach (var kvp in _predictedEntities)
            {
                var predicted = kvp.Value;

                if (!predicted.IsConfirmed &&
                    currentTime - predicted.SpawnTime > maxAge)
                {
                    // 预测超时未确认，回滚
                    RevertPrediction(kvp.Key);
                }
            }
        }
    }

    /// <summary>
    /// 预测实体数据结构
    /// </summary>
    public class PredictedEntity
    {
        public int EntityId;
        public Node Instance;
        public Vector3 PredictedPosition;
        public double SpawnTime;
        public bool IsConfirmed;
        public bool IsPredictedDestroyed;
        public double PredictedDestroyTime;
    }

    /// <summary>
    /// 实体工厂
    /// </summary>
    public class EntityFactory
    {
        public Node CreateEntity(EntityType type)
        {
            // 根据类型创建实体
            switch (type)
            {
                case EntityType.Player:
                    return new CharacterBody3D();
                case EntityType.Projectile:
                    return new RigidBody3D();
                default:
                    return new Node3D();
            }
        }
    }
}

12.3.3 心跳和连接保活

using Godot;
using System;

namespace GameFramework.Network.Sync
{
    /// <summary>
    /// 网络心跳管理器
    /// 保持连接活跃并测量延迟
    /// </summary>
    public partial class HeartbeatManager : Node
    {
        // 心跳配置
        [Export]
        public float HeartbeatInterval { get; set; } = 1.0f; // 每秒一次

        [Export]
        public float TimeoutThreshold { get; set; } = 5.0f; // 5秒超时

        // 状态
        private double _lastHeartbeatTime;
        private double _lastReceivedTime;
        private int _sequenceNumber;

        // 延迟统计
        public float CurrentLatency { get; private set; }
        public float AverageLatency { get; private set; }
        public float Jitter { get; private set; }

        [Signal]
        public delegate void LatencyUpdatedEventHandler(float latency);

        [Signal]
        public delegate void ConnectionTimeoutEventHandler();

        public override void _Ready()
        {
            _lastReceivedTime = Time.GetTicksMsec() / 1000.0;
        }

        public override void _Process(double delta)
        {
            double currentTime = Time.GetTicksMsec() / 1000.0;

            // 发送心跳
            if (currentTime - _lastHeartbeatTime >= HeartbeatInterval)
            {
                SendHeartbeat();
                _lastHeartbeatTime = currentTime;
            }

            // 检查超时
            if (currentTime - _lastReceivedTime > TimeoutThreshold)
            {
                GD.PushError("连接超时！");
                EmitSignal(SignalName.ConnectionTimeout);
            }
        }

        /// <summary>
        /// 发送心跳包
        /// </summary>
        private void SendHeartbeat()
        {
            var heartbeat = new HeartbeatMessage
            {
                SequenceNumber = _sequenceNumber++,
                ClientSendTime = Time.GetTicksMsec() / 1000.0
            };

            // 发送心跳RPC
            Rpc(MethodName.ReceiveHeartbeat, heartbeat.SequenceNumber, heartbeat.ClientSendTime);
        }

        /// <summary>
        /// 接收心跳响应
        /// </summary>
        [Rpc(MultiplayerApi.RpcMode.Authority)]
        private void ReceiveHeartbeat(int sequenceNumber, double clientSendTime)
        {
            double currentTime = Time.GetTicksMsec() / 1000.0;

            // 计算RTT
            float rtt = (float)(currentTime - clientSendTime);
            CurrentLatency = rtt * 0.5f; // 单向延迟

            // 更新平均延迟
            if (AverageLatency == 0)
            {
                AverageLatency = CurrentLatency;
            }
            else
            {
                AverageLatency = AverageLatency * 0.9f + CurrentLatency * 0.1f;
            }

            // 计算抖动
            float diff = Math.Abs(CurrentLatency - AverageLatency);
            Jitter = Jitter * 0.9f + diff * 0.1f;

            _lastReceivedTime = currentTime;

            EmitSignal(SignalName.LatencyUpdated, CurrentLatency);
        }

        /// <summary>
        /// 接收服务器心跳（服务器端）
        /// </summary>
        public void ProcessClientHeartbeat(int peerId, int sequenceNumber, double clientTime)
        {
            // 服务器立即回复
            RpcId(peerId, MethodName.ReceiveHeartbeat, sequenceNumber, clientTime);

            // 记录客户端活跃时间
            _lastReceivedTime = Time.GetTicksMsec() / 1000.0;
        }
    }

    /// <summary>
    /// 心跳消息结构
    /// </summary>
    public struct HeartbeatMessage
    {
        public int SequenceNumber;
        public double ClientSendTime;
    }
}

12.4 核心概念深入讲解

12.4.1 状态同步的本质

状态同步的本质是在多个独立运行的计算机之间维护一致的游戏世界视图。由于网络延迟和带宽限制，完全一致是不可能的，因此目标是达到"足够一致"——玩家感知不到差异或差异不影响游戏体验。

一致性模型：游戏网络通常使用最终一致性（Eventual Consistency），允许短暂的不一致，但保证所有客户端最终会收敛到相同状态。这与银行系统等需要强一致性的应用不同。

CAP定理在游戏中的应用：根据CAP定理，分布式系统无法同时保证一致性（Consistency）、可用性（Availability）和分区容错性（Partition Tolerance）。游戏网络通常优先保证可用性和分区容错性，通过牺牲严格一致性来换取流畅体验。

12.4.2 插值与预测的区别

插值（Interpolation）和预测（Prediction）是处理延迟的两种相反策略：

插值（延迟渲染）：客户端延迟显示收到的状态，使用过去的状态进行平滑插值。优点是状态确定，不会跳变；缺点是增加了固有延迟（通常是2-3个快照间隔）。

预测（提前渲染）：客户端根据当前输入预测未来状态并立即显示。优点是零延迟感知；缺点是预测错误时需要修正，可能导致跳变。

混合策略：现代游戏通常同时使用两者。玩家自己的角色使用预测，其他玩家使用插值。这样既有即时的操作反馈，又避免看到其他玩家跳来跳去。

12.4.3 带宽的物理限制

理解带宽限制有助于设计合理的同步策略：

带宽计算示例：假设100个玩家，每个玩家发送位置（12字节）+旋转（16字节）+速度（12字节）=40字节，每秒20次更新。

上行：40字节 × 20Hz = 800字节/秒/玩家
下行：40字节 × 20Hz × 99其他玩家 = 79.2KB/秒/玩家
服务器带宽：79.2KB × 100玩家 = 7.92MB/秒

优化后的实际带宽：使用Delta压缩和位压缩后，通常可以减少60-80%的带宽消耗。这就是为什么现代游戏能在家庭宽带上支持大量玩家。

12.5 实现细节深度分析

12.5.1 快照压缩算法

高效的快照压缩是状态同步的核心技术：

Delta压缩的数学原理：

发送数据 = 当前状态 XOR 基准状态
接收端重建：当前状态 = 基准状态 XOR 接收数据

这种异或操作利用了游戏状态的时间局部性——相邻帧之间变化很小，异或结果中大部分位为0，可以被高效压缩。

四元数压缩：旋转通常用四元数表示（4个float，16字节）。可以只发送3个分量，第4个通过单位四元数约束计算得出。进一步可以将每个分量量化为16位整数，将旋转数据压缩到6字节。

位置压缩策略：

绝对位置：首次同步或大幅移动时使用
相对位置（Delta）：小幅度移动时使用更小的位数
变长编码：根据移动幅度动态选择位数

12.5.2 插值算法的数学基础

线性插值（Lerp）：

result = a + (b - a) × t

最简单但可能产生不平滑的速度变化，适合快速移动的物体。

球面线性插值（Slerp）：用于旋转插值，保证角速度恒定。计算成本较高但视觉效果更自然。Godot的Quaternion.Slerp实现了这一算法。

Hermite样条插值：使用位置和速度信息构造三次多项式，产生平滑的加速度和减速度效果。适合载具和角色的移动插值。

Catmull-Rom样条：使用四个控制点构造曲线，保证经过所有关键点。适合回放系统，可以生成完全平滑的回放轨迹。

12.5.3 带宽分配算法

智能的带宽分配可以显著提升体验：

优先级计算公式：

优先级 = 距离因子 × 0.4 + 类型权重 × 0.3 + 移动速度 × 0.2 + 事件权重 × 0.1

自适应频率调整：

当带宽充足时，提高关键对象的同步频率
当检测到拥塞（丢包增加）时，降低非关键对象的频率
使用TCP友好的速率控制算法（如LEDBAT）

LOD（Level of Detail）同步：

近距离（0-10米）：完整状态，60Hz
中距离（10-30米）：位置和旋转，20Hz
远距离（30-100米）：仅位置，10Hz
超远距离（100米+）：低频位置或完全不同步

12.6 最佳实践指南

12.6.1 不同游戏类型的同步策略

竞技FPS（如CS:GO）：

服务器Tick Rate：64Hz或128Hz
客户端预测：必须
插值延迟：低至50-100ms
回滚机制：用于射击判定

大逃杀游戏（如PUBG）：

服务器Tick Rate：20-30Hz
兴趣管理：只同步附近玩家
区域服务器：分区物理模拟
载具特殊处理：高优先级同步

MOBA游戏（如Dota 2）：

服务器Tick Rate：30Hz
确定性模拟：客户端可以预测技能效果
技能同步：关键事件可靠传输
小地图：低频更新，允许延迟

MMORPG（如WoW）：

服务器Tick Rate：10-20Hz
实例化：副本内高频，野外低频
优先级队列：战斗中对象优先
批量更新：合并多个小更新

12.6.2 常见问题与解决方案

问题1：玩家看到其他玩家"瞬移"

原因：丢包导致缺少中间状态
解决：增加冗余，使用外推预测短暂丢失的数据

问题2：带宽突然飙升

原因：大量对象同时变化（如爆炸场景）
解决：实施带宽上限，优先发送关键数据，延迟发送非关键数据

问题3：高延迟玩家体验差

原因：插值延迟叠加网络延迟
解决：为不同延迟玩家提供补偿，或匹配到延迟相近的服务器

问题4：作弊者伪造状态

原因：客户端发送虚假位置数据
解决：服务器权威验证，速度检测，异常行为标记

12.6.3 性能调优检查清单

同步配置检查：

同步频率是否根据距离动态调整
是否只同步可见/相关对象
Delta压缩是否正确实现
插值延迟是否适合游戏类型

带宽使用检查：

监控每帧发送字节数
识别带宽峰值的原因
优化最大玩家的带宽占用
测试网络拥塞时的表现

质量检查：

高延迟（200ms+）下的游戏体验
丢包（5%、10%）下的表现
大量玩家同屏时的帧率
移动设备上的电池消耗

本章小结：

快照同步：通过定期发送完整状态快照保持客户端一致，使用插值平滑过渡
Delta压缩：只发送状态变化部分，大幅减少带宽使用
位级压缩：使用紧凑的二进制表示进一步减少数据量
带宽优化：基于距离和优先级动态调整同步频率
预测机制：客户端预测实体生成和销毁，减少感知延迟

性能对比：

技术	带宽节省	CPU开销	延迟影响
快照同步	基准	低	+100ms（插值延迟）
Delta压缩	60-80%	中	无
位压缩	50-70%	低	无
优先级LOD	40-60%	低	无
预测生成	-10%	高	-200ms

#Godot #开发 #C# #架构 #CSharp #同步策略