第11章网络基础架构

2026年4月25日 · 游戏开发

11.1 多人游戏架构模式

在多人游戏开发中，选择合适的网络架构是至关重要的决策，它直接影响游戏的性能、安全性、开发复杂度以及玩家体验。

11.1.1 客户端-服务器架构（Client/Server）

C/S架构是当前多人游戏中最常用的模式，特点是所有游戏逻辑和状态都由服务器权威控制。

架构原理：

┌─────────────┐      ┌─────────────┐      ┌─────────────┐
│   客户端A   │◄────►│             │◄────►│   客户端B   │
└─────────────┘      │   服务器    │      └─────────────┘
┌─────────────┐      │  (权威)     │      ┌─────────────┐
│   客户端C   │◄────►│             │◄────►│   客户端D   │
└─────────────┘      └─────────────┘      └─────────────┘

优势：

安全性：服务器拥有完全权威，防止客户端作弊
一致性：所有客户端看到统一的游戏状态
公平性：网络延迟对游戏结果影响相对较小

劣势：

延迟问题：玩家输入需要到达服务器处理后再返回显示
服务器成本：需要部署和维护专用服务器
开发复杂度：需要处理客户端预测和服务器调和

11.1.2 点对点架构（P2P）

P2P架构中，所有玩家节点地位平等，直接相互通信。

架构原理：

┌─────────────┐◄─────────────────────────────►┌─────────────┐
│   玩家A     │◄─────────────────────────────►│   玩家B     │
└─────────────┘◄──┐                     ┌──►└─────────────┘
                  │                     │
                  ▼                     ▼
           ┌─────────────┐       ┌─────────────┐
           │   玩家C     │◄─────►│   玩家D     │
           └─────────────┘       └─────────────┘

优势：

低延迟：玩家之间直接通信，无需经过中心服务器
零服务器成本：不需要维护专用服务器
适合局域网：本地多人游戏体验优秀

劣势：

安全性问题：容易受到作弊影响
同步难题：需要复杂的同步协议保证一致性
网络要求高：每个玩家需要良好的上行带宽
断线问题：一个玩家退出可能影响整个游戏

11.1.3 混合架构

混合架构结合了C/S和P2P的优点，根据游戏类型灵活选择。

常见混合模式：

主机模式（Host/Client）
- 一名玩家充当服务器角色
- 适合合作游戏、小规模对战

┌─────────────┐      ┌─────────────┐      ┌─────────────┐
│   客户端    │◄────►│   主机      │◄────►│   客户端    │
└─────────────┘      │  (服务器)   │      └─────────────┘
                     └─────────────┘

中继服务器模式
- 使用服务器转发消息，但不运行游戏逻辑
- 平衡安全性和延迟
区域服务器模式
- 不同区域使用不同架构
- 全局用C/S，局部用P2P

11.2 Godot MultiplayerAPI 深度解析

Godot 4.0引入了全新的多人游戏API，大大简化了网络开发流程。

11.2.1 MultiplayerPeer 网络对等体

MultiplayerPeer是所有网络连接的抽象基类，负责底层网络通信。

核心功能：

using Godot;
using System;

namespace GameFramework.Network
{
    /// <summary>
    /// 网络对等体管理器
    /// 负责建立和维护网络连接
    /// </summary>
    public class NetworkPeerManager : Node
    {
        // 网络对等体实例
        private MultiplayerPeer _multiplayerPeer;

        // 网络模式枚举
        public enum NetworkMode
        {
            Server,      // 服务器模式
            Client,      // 客户端模式
            Host         // 主机模式（兼具服务器和客户端）
        }

        [Export]
        public NetworkMode Mode { get; set; } = NetworkMode.Client;

        [Export]
        public int Port { get; set; } = 7777;

        [Export]
        public string ServerAddress { get; set; } = "127.0.0.1";

        /// <summary>
        /// 创建服务器
        /// </summary>
        public Error CreateServer(int maxClients = 32)
        {
            // 创建ENet网络对等体
            var peer = new ENetMultiplayerPeer();

            // 创建服务器，监听指定端口
            Error error = peer.CreateServer(Port, maxClients);

            if (error != Error.Ok)
            {
                GD.PushError($"创建服务器失败: {error}");
                return error;
            }

            _multiplayerPeer = peer;
            Multiplayer.MultiplayerPeer = _multiplayerPeer;

            GD.Print($"服务器已在端口 {Port} 启动，最大客户端数: {maxClients}");
            return Error.Ok;
        }

        /// <summary>
        /// 创建客户端
        /// </summary>
        public Error CreateClient()
        {
            var peer = new ENetMultiplayerPeer();

            // 连接到服务器
            Error error = peer.CreateClient(ServerAddress, Port);

            if (error != Error.Ok)
            {
                GD.PushError($"创建客户端失败: {error}");
                return error;
            }

            _multiplayerPeer = peer;
            Multiplayer.MultiplayerPeer = _multiplayerPeer;

            GD.Print($"正在连接到服务器 {ServerAddress}:{Port}");
            return Error.Ok;
        }

        /// <summary>
        /// 创建主机（客户端兼服务器）
        /// </summary>
        public Error CreateHost(int maxClients = 8)
        {
            // 先创建服务器
            Error error = CreateServer(maxClients);
            if (error != Error.Ok)
                return error;

            Mode = NetworkMode.Host;
            GD.Print("主机模式已启动");
            return Error.Ok;
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        public void Disconnect()
        {
            if (_multiplayerPeer != null)
            {
                _multiplayerPeer.Close();
                _multiplayerPeer = null;
                GD.Print("网络连接已断开");
            }
        }

        /// <summary>
        /// 获取当前连接的延迟
        /// </summary>
        public int GetLatency(int peerId)
        {
            if (_multiplayerPeer is ENetMultiplayerPeer enetPeer)
            {
                // 获取对等体的往返时间（RTT）
                return enetPeer.GetPeerRTT(peerId);
            }
            return -1;
        }

        /// <summary>
        /// 设置网络通道
        /// </summary>
        public void ConfigureChannels(int channels)
        {
            // ENet支持多通道，可以在不同通道发送不同类型的数据
            // 通道0：可靠有序（默认）
            // 通道1：不可靠无序（适合频繁更新的状态）
            // 通道2：可靠无序（适合重要但不按序的消息）
        }

        /// <summary>
        /// 发送原始数据包
        /// </summary>
        public void SendPacket(byte[] data, int peerId, MultiplayerPeer.TransferMode mode)
        {
            if (_multiplayerPeer == null)
                return;

            // 发送数据到指定对等体
            _multiplayerPeer.Send(peerId, data, 0, mode);
        }
    }
}

传输模式说明：

模式	特性	适用场景
Reliable	可靠传输，保证送达，按顺序	重要事件、状态变更
Unreliable	不可靠传输，可能丢失	高频状态更新、位置同步
ReliableOrdered	可靠有序，保证顺序	RPC调用、关键游戏事件
UnreliableOrdered	不可靠但有序	较少使用

11.2.2 MultiplayerSynchronizer 状态同步器

MultiplayerSynchronizer是Godot 4.0中用于自动同步节点属性的组件。

基本配置：

using Godot;

namespace GameFramework.Network
{
    /// <summary>
    /// 网络同步配置
    /// 用于配置需要自动同步的属性
    /// </summary>
    [GlobalClass]
    public partial class NetworkSyncConfig : Resource
    {
        [Export]
        public string PropertyPath { get; set; }

        [Export]
        public float SyncInterval { get; set; } = 0.05f; // 20Hz

        [Export]
        public MultiplayerSynchronizer.SyncMode SyncMode { get; set; } =
            MultiplayerSynchronizer.SyncMode.Visibility;
    }

    /// <summary>
    /// 自定义网络同步器
    /// 包装Godot的MultiplayerSynchronizer提供额外功能
    /// </summary>
    public partial class CustomMultiplayerSynchronizer : Node
    {
        private MultiplayerSynchronizer _synchronizer;
        private Node _target;

        /// <summary>
        /// 初始化同步器
        /// </summary>
        public void Initialize(Node target)
        {
            _target = target;

            // 创建同步器节点
            _synchronizer = new MultiplayerSynchronizer();
            _synchronizer.Name = "MultiplayerSynchronizer";
            AddChild(_synchronizer);

            // 设置根节点
            _synchronizer.RootPath = target.GetPath();
        }

        /// <summary>
        /// 添加同步属性
        /// </summary>
        public void AddSyncProperty(string propertyPath, float interval = 0.05f)
        {
            if (_synchronizer == null)
            {
                GD.PushError("同步器未初始化");
                return;
            }

            // 创建同步属性配置
            var config = new SceneReplicationConfig();

            // 添加属性路径
            NodePath nodePath = new NodePath(propertyPath);
            config.AddProperty(nodePath);

            // 设置同步间隔
            config.PropertyGetSpawn(nodePath, true);
            config.PropertyGetSyncInterval(nodePath, interval);

            _synchronizer.ReplicationConfig = config;
        }

        /// <summary>
        /// 设置权限（谁有权修改）
        /// </summary>
        public void SetAuthority(int peerId)
        {
            _synchronizer.SetMultiplayerAuthority(peerId);
        }

        /// <summary>
        /// 启用/禁用同步
        /// </summary>
        public void SetSyncEnabled(bool enabled)
        {
            _synchronizer.VisibilityUpdateMode = enabled ?
                MultiplayerSynchronizer.VisibilityUpdateMode.All :
                MultiplayerSynchronizer.VisibilityUpdateMode.None;
        }
    }
}

高级同步策略：

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

namespace GameFramework.Network
{
    /// <summary>
    /// 高级网络同步管理器
    /// 实现带宽优化和优先级同步
    /// </summary>
    public partial class AdvancedSyncManager : Node
    {
        // 同步对象列表
        private Dictionary<int, SyncObjectData> _syncObjects = new();

        // 优先级队列
        private PriorityQueue<int, float> _syncQueue = new();

        // 带宽限制（字节/秒）
        [Export]
        public float BandwidthLimit { get; set; } = 50000f;

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

        /// <summary>
        /// 同步对象数据结构
        /// </summary>
        private struct SyncObjectData
        {
            public Node Node;
            public MultiplayerSynchronizer Synchronizer;
            public float Priority;
            public float LastSyncTime;
            public Vector3 LastPosition;
            public bool HasChanged;
        }

        public override void _Ready()
        {
            // 注册场景树变化事件
            GetTree().NodeAdded += OnNodeAdded;
            GetTree().NodeRemoved += OnNodeRemoved;
        }

        /// <summary>
        /// 节点加入场景树时注册
        /// </summary>
        private void OnNodeAdded(Node node)
        {
            if (node is ISyncable syncable)
            {
                RegisterSyncObject(node, syncable.GetSyncPriority());
            }
        }

        /// <summary>
        /// 节点移除时注销
        /// </summary>
        private void OnNodeRemoved(Node node)
        {
            if (_syncObjects.ContainsKey(node.GetInstanceId()))
            {
                UnregisterSyncObject(node.GetInstanceId());
            }
        }

        /// <summary>
        /// 注册同步对象
        /// </summary>
        public void RegisterSyncObject(Node node, float priority)
        {
            var synchronizer = node.GetNodeOrNull<MultiplayerSynchronizer>("MultiplayerSynchronizer");

            if (synchronizer == null)
            {
                synchronizer = new MultiplayerSynchronizer();
                node.AddChild(synchronizer);
            }

            int id = node.GetInstanceId();
            _syncObjects[id] = new SyncObjectData
            {
                Node = node,
                Synchronizer = synchronizer,
                Priority = priority,
                LastSyncTime = Time.GetTicksMsec() / 1000f,
                LastPosition = node is Node3D n3d ? n3d.GlobalPosition : Vector3.Zero,
                HasChanged = true
            };
        }

        /// <summary>
        /// 注销同步对象
        /// </summary>
        public void UnregisterSyncObject(int id)
        {
            if (_syncObjects.Remove(id))
            {
                GD.Print($"同步对象 {id} 已注销");
            }
        }

        public override void _Process(double delta)
        {
            // 每帧重置带宽计数
            _currentBandwidthUsage = 0f;

            // 更新对象优先级
            UpdatePriorities();

            // 根据带宽限制执行同步
            ProcessSyncQueue();
        }

        /// <summary>
        /// 更新同步优先级
        /// </summary>
        private void UpdatePriorities()
        {
            float currentTime = Time.GetTicksMsec() / 1000f;

            foreach (var kvp in _syncObjects)
            {
                var data = kvp.Value;

                // 计算距离变化
                if (data.Node is Node3D node3d)
                {
                    float distance = data.LastPosition.DistanceTo(node3d.GlobalPosition);
                    data.HasChanged = distance > 0.01f;

                    // 动态调整优先级：移动越多，优先级越高
                    float movementPriority = Mathf.Min(distance * 10f, 1f);
                    data.Priority = movementPriority;
                }

                // 计算时间因子：越长时间未同步，优先级越高
                float timeSinceLastSync = currentTime - data.LastSyncTime;
                float timePriority = Mathf.Min(timeSinceLastSync * 0.1f, 1f);

                // 综合优先级
                float finalPriority = (data.Priority + timePriority) * 0.5f;
                data.Priority = finalPriority;

                _syncObjects[kvp.Key] = data;
            }
        }

        /// <summary>
        /// 处理同步队列
        /// </summary>
        private void ProcessSyncQueue()
        {
            // 按优先级排序
            var sortedObjects = new List<KeyValuePair<int, SyncObjectData>>(_syncObjects);
            sortedObjects.Sort((a, b) => b.Value.Priority.CompareTo(a.Value.Priority));

            foreach (var kvp in sortedObjects)
            {
                if (_currentBandwidthUsage >= BandwidthLimit)
                    break;

                var data = kvp.Value;

                // 估算此对象同步所需带宽
                float estimatedSize = EstimateSyncSize(data);

                if (_currentBandwidthUsage + estimatedSize <= BandwidthLimit)
                {
                    // 执行同步
                    PerformSync(kvp.Key);
                    _currentBandwidthUsage += estimatedSize;
                }
            }
        }

        /// <summary>
        /// 估算同步数据大小
        /// </summary>
        private float EstimateSyncSize(SyncObjectData data)
        {
            // 基础开销 + 属性大小
            // 位置：12字节（Vector3）
            // 旋转：16字节（Quaternion）
            // 缩放：12字节（Vector3）
            return 40f;
        }

        /// <summary>
        /// 执行同步
        /// </summary>
        private void PerformSync(int id)
        {
            if (!_syncObjects.TryGetValue(id, out var data))
                return;

            // 更新同步时间
            data.LastSyncTime = Time.GetTicksMsec() / 1000f;

            // 更新最后位置
            if (data.Node is Node3D node3d)
            {
                data.LastPosition = node3d.GlobalPosition;
            }

            _syncObjects[id] = data;
        }
    }

    /// <summary>
    /// 可同步对象接口
    /// </summary>
    public interface ISyncable
    {
        float GetSyncPriority();
    }
}

11.2.3 MultiplayerSpawner 网络生成器

MultiplayerSpawner用于自动处理网络对象的生成和销毁同步。

using Godot;
using System.Collections.Generic;

namespace GameFramework.Network
{
    /// <summary>
    /// 网络对象生成管理器
    /// 管理所有网络生成对象的声明周期
    /// </summary>
    public partial class NetworkSpawnManager : Node
    {
        // 生成器实例
        private MultiplayerSpawner _spawner;

        // 可生成对象的预制体场景
        [Export]
        public Godot.Collections.Array<PackedScene> SpawnableScenes { get; set; }

        // 已生成对象跟踪
        private Dictionary<int, Node> _spawnedObjects = new();
        private int _nextSpawnId = 1;

        public override void _Ready()
        {
            // 创建生成器
            _spawner = new MultiplayerSpawner();
            _spawner.Name = "MultiplayerSpawner";
            AddChild(_spawner);

            // 配置生成路径
            _spawner.SpawnPath = new NodePath("../SpawnedObjects");

            // 添加可生成场景
            if (SpawnableScenes != null)
            {
                foreach (var scene in SpawnableScenes)
                {
                    _spawner.AddSpawnableScene(scene.ResourcePath);
                }
            }

            // 监听生成事件
            _spawner.Spawned += OnObjectSpawned;
            _spawner.Despawned += OnObjectDespawned;
        }

        /// <summary>
        /// 网络生成对象
        /// </summary>
        public Node SpawnObject(PackedScene scene, Vector3 position, int authorityPeer = 1)
        {
            if (!Multiplayer.IsServer())
            {
                GD.PushError("只有服务器可以生成网络对象");
                return null;
            }

            // 生成对象
            var instance = scene.Instantiate();

            // 设置位置
            if (instance is Node3D node3d)
            {
                node3d.GlobalPosition = position;
            }

            // 添加到场景
            GetNode(_spawner.SpawnPath).AddChild(instance);

            // 设置网络权限
            if (instance is MultiplayerSynchronizer sync)
            {
                sync.SetMultiplayerAuthority(authorityPeer);
            }

            // 跟踪生成对象
            int spawnId = _nextSpawnId++;
            _spawnedObjects[spawnId] = instance;
            instance.SetMeta("spawn_id", spawnId);

            GD.Print($"网络对象已生成: {instance.Name}, ID: {spawnId}");
            return instance;
        }

        /// <summary>
        /// 网络销毁对象
        /// </summary>
        public void DespawnObject(Node instance)
        {
            if (!Multiplayer.IsServer())
            {
                GD.PushError("只有服务器可以销毁网络对象");
                return;
            }

            // 从跟踪中移除
            if (instance.HasMeta("spawn_id"))
            {
                int spawnId = (int)instance.GetMeta("spawn_id");
                _spawnedObjects.Remove(spawnId);
            }

            // 从场景中移除
            instance.QueueFree();

            GD.Print($"网络对象已销毁: {instance.Name}");
        }

        /// <summary>
        /// 对象生成回调
        /// </summary>
        private void OnObjectSpawned(Node spawnedNode)
        {
            GD.Print($"接收到网络生成对象: {spawnedNode.Name}");

            // 执行初始化
            if (spawnedNode is INetworkSpawnable spawnable)
            {
                spawnable.OnNetworkSpawn();
            }
        }

        /// <summary>
        /// 对象销毁回调
        /// </summary>
        private void OnObjectDespawned(Node node)
        {
            GD.Print($"网络对象被销毁: {node.Name}");
        }

        /// <summary>
        /// 获取所有生成的对象
        /// </summary>
        public IEnumerable<Node> GetSpawnedObjects()
        {
            return _spawnedObjects.Values;
        }
    }

    /// <summary>
    /// 网络可生成对象接口
    /// </summary>
    public interface INetworkSpawnable
    {
        void OnNetworkSpawn();
        void OnNetworkDespawn();
    }
}

11.3 网络拓扑选择与延迟优化

11.3.1 网络拓扑选择指南

根据游戏类型选择架构：

using Godot;

namespace GameFramework.Network
{
    /// <summary>
    /// 网络拓扑推荐器
    /// 根据游戏特征推荐合适的网络架构
    /// </summary>
    public class NetworkTopologyAdvisor
    {
        public enum GameGenre
        {
            FPS,           // 第一人称射击
            RTS,           // 即时战略
            MOBA,          // 多人在线战术竞技
            MMO,           // 大型多人在线
            Fighting,      // 格斗游戏
            Racing,        // 竞速游戏
            Casual         // 休闲游戏
        }

        /// <summary>
        /// 获取推荐的网络架构
        /// </summary>
        public static string GetRecommendedArchitecture(GameGenre genre)
        {
            switch (genre)
            {
                case GameGenre.FPS:
                    return "客户端-服务器 + 客户端预测 + 服务器调和";

                case GameGenre.RTS:
                    return "确定性帧同步 + 指令延迟执行";

                case GameGenre.MOBA:
                    return "客户端-服务器 + 状态插值";

                case GameGenre.MMO:
                    return "分布式服务器 + 区域划分 + 兴趣管理";

                case GameGenre.Fighting:
                    return "帧同步 + 回滚网络（Rollback Netcode）";

                case GameGenre.Racing:
                    return "客户端-服务器 + 物理预测";

                case GameGenre.Casual:
                    return "主机模式或中继服务器";

                default:
                    return "客户端-服务器";
            }
        }

        /// <summary>
        /// 获取推荐的同步频率
        /// </summary>
        public static int GetRecommendedTickRate(GameGenre genre)
        {
            switch (genre)
            {
                case GameGenre.FPS:
                    return 60;  // 高频率，快速反应

                case GameGenre.Fighting:
                    return 60;  // 格斗游戏需要精确帧同步

                case GameGenre.RTS:
                    return 20;  // RTS可以接受较低频率

                case GameGenre.MOBA:
                    return 30;  // MOBA平衡性能和精度

                case GameGenre.MMO:
                    return 20;  // MMO需要节省带宽

                case GameGenre.Racing:
                    return 60;  // 竞速需要平滑移动

                default:
                    return 30;
            }
        }
    }
}

11.3.2 延迟优化策略

设计思路与原理

网络延迟是多人游戏体验的最大敌人。延迟优化需要从多个层面入手，包括协议选择、数据传输优化、本地预测等。

延迟来源分析：

传输延迟：数据在网络中传输的时间（光速限制）
处理延迟：服务器处理请求的时间
排队延迟：数据包等待处理的时间
抖动：延迟的不稳定性

优化策略：

插值与预测：平滑位置更新，预测玩家移动
本地回显：玩家操作立即在本地生效
延迟补偿：服务器根据延迟回溯判定
数据压缩：减少传输数据量

核心实现要点

延迟测量：定期ping测量网络延迟
插值延迟：使用插值缓冲平滑位置更新
带宽适配：根据网络状况调整更新频率
优先级队列：重要数据优先发送

使用说明与最佳 practices

适用场景：多人对战、合作游戏、实时同步
注意事项：
1. 预测错误时要有平滑的修正
2. 不同玩家的延迟差异要处理
3. 网络断开时的处理
性能考虑：使用UDP而非TCP降低延迟
扩展建议：可添加区域服务器、网络质量检测、自适应码率等

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

namespace GameFramework.Network
{
    /// <summary>
    /// 网络延迟优化管理器
    /// 提供多种技术降低感知延迟
    /// </summary>
    public partial class LatencyOptimizer : Node
    {
        // 延迟统计
        private List<float> _latencySamples = new();
        private const int MaxSamples = 50;

        // 当前估计延迟
        public float EstimatedLatency { get; private set; } = 0.05f;
        public float EstimatedJitter { get; private set; } = 0.01f;

        /// <summary>
        /// 记录延迟样本
        /// </summary>
        public void RecordLatency(float latency)
        {
            _latencySamples.Add(latency);

            if (_latencySamples.Count > MaxSamples)
            {
                _latencySamples.RemoveAt(0);
            }

            // 计算统计值
            CalculateStatistics();
        }

        /// <summary>
        /// 计算延迟统计
        /// </summary>
        private void CalculateStatistics()
        {
            if (_latencySamples.Count == 0)
                return;

            // 计算平均值
            float sum = 0f;
            foreach (var sample in _latencySamples)
            {
                sum += sample;
            }
            float mean = sum / _latencySamples.Count;

            // 计算抖动（方差）
            float variance = 0f;
            foreach (var sample in _latencySamples)
            {
                variance += (sample - mean) * (sample - mean);
            }
            variance /= _latencySamples.Count;

            // 平滑更新
            EstimatedLatency = Mathf.Lerp(EstimatedLatency, mean, 0.1f);
            EstimatedJitter = Mathf.Lerp(EstimatedJitter, Mathf.Sqrt(variance), 0.1f);
        }

        /// <summary>
        /// 获取插值延迟
        /// 用于平滑网络位置插值
        /// </summary>
        public float GetInterpolationDelay()
        {
            // 插值延迟 = 当前延迟 + 2倍抖动缓冲
            return EstimatedLatency + EstimatedJitter * 2f;
        }

        /// <summary>
        /// 判断是否需要预测补偿
        /// </summary>
        public bool ShouldUsePrediction()
        {
            // 延迟超过100ms时启用预测
            return EstimatedLatency > 0.1f;
        }
    }

    /// <summary>
    /// 网络压缩工具
    /// 减少网络传输数据量
    /// </summary>
    public static class NetworkCompression
    {
        /// <summary>
        /// 压缩位置数据（半精度）
        /// </summary>
        public static byte[] CompressPosition(Vector3 position, float precision = 0.01f)
        {
            // 使用半精度浮点数压缩
            // 将float16打包为2字节
            byte[] data = new byte[6];

            // 简化的压缩示例：乘以精度系数后转short
            short x = (short)(position.X / precision);
            short y = (short)(position.Y / precision);
            short z = (short)(position.Z / precision);

            data[0] = (byte)(x & 0xFF);
            data[1] = (byte)(x >> 8);
            data[2] = (byte)(y & 0xFF);
            data[3] = (byte)(y >> 8);
            data[4] = (byte)(z & 0xFF);
            data[5] = (byte)(z >> 8);

            return data;
        }

        /// <summary>
        /// 解压缩位置数据
        /// </summary>
        public static Vector3 DecompressPosition(byte[] data, float precision = 0.01f)
        {
            short x = (short)(data[0] | (data[1] << 8));
            short y = (short)(data[2] | (data[3] << 8));
            short z = (short)(data[4] | (data[5] << 8));

            return new Vector3(
                x * precision,
                y * precision,
                z * precision
            );
        }

        /// <summary>
        /// 压缩旋转数据（四元数压缩）
        /// </summary>
        public static byte[] CompressRotation(Quaternion rotation)
        {
            // 四元数压缩：只发送3个分量，第4个通过计算得到
            // 选择绝对值最大的分量省略
            byte[] data = new byte[3];

            float[] components = { rotation.X, rotation.Y, rotation.Z, rotation.W };
            int maxIndex = 0;
            float maxValue = Math.Abs(components[0]);

            for (int i = 1; i < 4; i++)
            {
                if (Math.Abs(components[i]) > maxValue)
                {
                    maxValue = Math.Abs(components[i]);
                    maxIndex = i;
                }
            }

            // 将其他三个分量量化为字节（-1到1映射到0-255）
            int writeIndex = 0;
            for (int i = 0; i < 4; i++)
            {
                if (i != maxIndex)
                {
                    data[writeIndex] = (byte)((components[i] + 1f) * 0.5f * 255f);
                    writeIndex++;
                }
            }

            return data;
        }

        /// <summary>
        /// 使用增量压缩
        /// 只发送与上一帧的差异
        /// </summary>
        public static byte[] CompressDelta(Vector3 current, Vector3 previous, float threshold = 0.001f)
        {
            Vector3 delta = current - previous;

            // 如果变化小于阈值，返回空（不发送）
            if (delta.LengthSquared() < threshold * threshold)
            {
                return new byte[0];
            }

            // 压缩delta值（通常比绝对值小，可以用更少位数）
            return CompressPosition(delta, 0.001f);
        }
    }
}

11.4 完整网络管理器实现

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

namespace GameFramework.Network
{
    /// <summary>
    /// 网络管理器
    /// 游戏网络系统的核心管理类
    /// </summary>
    public partial class NetworkManager : Node
    {
        // 单例实例
        public static NetworkManager Instance { get; private set; }

        // 网络对等体
        private MultiplayerPeer _peer;

        // 子系统
        private LatencyOptimizer _latencyOptimizer;
        private NetworkSpawnManager _spawnManager;
        private AdvancedSyncManager _syncManager;

        // 玩家映射
        private Dictionary<int, NetworkedPlayer> _players = new();

        // 网络状态
        public enum NetworkState
        {
            Disconnected,
            Connecting,
            Connected,
            Host
        }
        public NetworkState State { get; private set; } = NetworkState.Disconnected;

        // 服务器时间同步
        public double ServerTime { get; private set; }
        public double LocalTimeOffset { get; private set; }

        [Signal]
        public delegate void PlayerConnectedEventHandler(int peerId, NetworkedPlayer player);

        [Signal]
        public delegate void PlayerDisconnectedEventHandler(int peerId);

        [Signal]
        public delegate void ConnectionFailedEventHandler();

        public override void _Ready()
        {
            Instance = this;

            // 初始化子系统
            _latencyOptimizer = new LatencyOptimizer();
            AddChild(_latencyOptimizer);

            _spawnManager = new NetworkSpawnManager();
            AddChild(_spawnManager);

            _syncManager = new AdvancedSyncManager();
            AddChild(_syncManager);

            // 注册网络回调
            Multiplayer.PeerConnected += OnPeerConnected;
            Multiplayer.PeerDisconnected += OnPeerDisconnected;
            Multiplayer.ConnectedToServer += OnConnectedToServer;
            Multiplayer.ConnectionFailed += OnConnectionFailed;
            Multiplayer.ServerDisconnected += OnServerDisconnected;
        }

        /// <summary>
        /// 作为服务器启动
        /// </summary>
        public Error StartServer(int port = 7777, int maxClients = 32)
        {
            var peer = new ENetMultiplayerPeer();
            Error error = peer.CreateServer(port, maxClients);

            if (error != Error.Ok)
            {
                GD.PushError($"启动服务器失败: {error}");
                EmitSignal(SignalName.ConnectionFailed);
                return error;
            }

            _peer = peer;
            Multiplayer.MultiplayerPeer = _peer;
            State = NetworkState.Host;

            GD.Print($"服务器启动成功，端口: {port}");
            return Error.Ok;
        }

        /// <summary>
        /// 作为客户端连接
        /// </summary>
        public Error StartClient(string address, int port = 7777)
        {
            var peer = new ENetMultiplayerPeer();
            Error error = peer.CreateClient(address, port);

            if (error != Error.Ok)
            {
                GD.PushError($"创建客户端失败: {error}");
                return error;
            }

            _peer = peer;
            Multiplayer.MultiplayerPeer = _peer;
            State = NetworkState.Connecting;

            GD.Print($"正在连接服务器 {address}:{port}");
            return Error.Ok;
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        public void Disconnect()
        {
            if (_peer != null)
            {
                _peer.Close();
                _peer = null;
                Multiplayer.MultiplayerPeer = null;
            }

            State = NetworkState.Disconnected;
            _players.Clear();

            GD.Print("已断开网络连接");
        }

        // 网络事件处理
        private void OnPeerConnected(long peerId)
        {
            GD.Print($"玩家连接: {peerId}");

            // 创建玩家对象
            var player = CreatePlayer((int)peerId);
            _players[(int)peerId] = player;

            // 同步时间
            RpcId((int)peerId, MethodName.SyncTime, Time.GetTicksMsec() / 1000.0);

            EmitSignal(SignalName.PlayerConnected, (int)peerId, player);
        }

        private void OnPeerDisconnected(long peerId)
        {
            GD.Print($"玩家断开: {peerId}");

            if (_players.TryGetValue((int)peerId, out var player))
            {
                player.QueueFree();
                _players.Remove((int)peerId);
            }

            EmitSignal(SignalName.PlayerDisconnected, (int)peerId);
        }

        private void OnConnectedToServer()
        {
            GD.Print("已连接到服务器");
            State = NetworkState.Connected;

            // 创建本地玩家
            var localPlayer = CreatePlayer(Multiplayer.GetUniqueId());
            _players[Multiplayer.GetUniqueId()] = localPlayer;
        }

        private void OnConnectionFailed()
        {
            GD.PushError("连接服务器失败");
            State = NetworkState.Disconnected;
            EmitSignal(SignalName.ConnectionFailed);
        }

        private void OnServerDisconnected()
        {
            GD.PushWarning("与服务器断开连接");
            Disconnect();
        }

        /// <summary>
        /// 创建玩家对象
        /// </summary>
        private NetworkedPlayer CreatePlayer(int peerId)
        {
            var player = new NetworkedPlayer();
            player.Name = $"Player_{peerId}";
            player.PeerId = peerId;
            AddChild(player);

            return player;
        }

        /// <summary>
        /// 时间同步RPC
        /// </summary>
        [Rpc(MultiplayerApi.RpcMode.Authority)]
        private void SyncTime(double serverTime)
        {
            double clientTime = Time.GetTicksMsec() / 1000.0;
            double rtt = clientTime - serverTime;
            double oneWayLatency = rtt * 0.5;

            LocalTimeOffset = serverTime + oneWayLatency - clientTime;
            ServerTime = clientTime + LocalTimeOffset;

            GD.Print($"时间同步完成，延迟: {oneWayLatency * 1000:F2}ms");
        }

        /// <summary>
        /// 获取网络时间
        /// </summary>
        public double GetNetworkTime()
        {
            return Time.GetTicksMsec() / 1000.0 + LocalTimeOffset;
        }

        /// <summary>
        /// 判断是否是本地玩家
        /// </summary>
        public bool IsLocalPlayer(int peerId)
        {
            return peerId == Multiplayer.GetUniqueId();
        }

        /// <summary>
        /// 判断是否是服务器
        /// </summary>
        public bool IsServer()
        {
            return Multiplayer.IsServer();
        }
    }

    /// <summary>
    /// 网络化玩家类
    /// </summary>
    public partial class NetworkedPlayer : CharacterBody3D
    {
        public int PeerId { get; set; }

        // 玩家数据
        public string PlayerName { get; set; } = "Player";
        public int TeamId { get; set; } = 0;
        public bool IsReady { get; set; } = false;

        // 网络同步组件
        private MultiplayerSynchronizer _synchronizer;

        public override void _Ready()
        {
            // 添加同步器
            _synchronizer = new MultiplayerSynchronizer();
            AddChild(_synchronizer);

            // 设置权限
            _synchronizer.SetMultiplayerAuthority(PeerId);
        }

        /// <summary>
        /// 更新玩家数据
        /// </summary>
        [Rpc(MultiplayerApi.RpcMode.Authority, CallLocal = true)]
        public void UpdatePlayerData(string name, int teamId)
        {
            PlayerName = name;
            TeamId = teamId;
        }
    }

    /// <summary>
    /// 网络消息类型定义
    /// </summary>
    public enum NetworkMessageType : byte
    {
        // 系统消息 (0-9)
        Handshake = 0,       // 握手
        Heartbeat = 1,       // 心跳
        Disconnect = 2,      // 断开连接
        TimeSync = 3,        // 时间同步

        // 游戏状态 (10-29)
        GameState = 10,      // 游戏状态更新
        PlayerSpawn = 11,    // 玩家生成
        PlayerDespawn = 12,  // 玩家销毁
        ObjectSpawn = 13,    // 对象生成
        ObjectDestroy = 14,  // 对象销毁

        // 玩家输入 (30-39)
        PlayerInput = 30,    // 玩家输入
        PlayerAction = 31,   // 玩家动作
        AbilityCast = 32,    // 技能释放

        // 物理状态 (40-49)
        PositionUpdate = 40, // 位置更新
        RotationUpdate = 41, // 旋转更新
        VelocityUpdate = 42, // 速度更新

        // 游戏事件 (50-69)
        Damage = 50,         // 伤害
        Death = 51,          // 死亡
        Score = 52,          // 得分
        MatchStart = 53,     // 比赛开始
        MatchEnd = 54,       // 比赛结束

        // 聊天和社交 (70-79)
        Chat = 70,           // 聊天消息
        TeamChat = 71,       // 队伍聊天
        Emote = 72,          // 表情

        // 自定义消息 (200-255)
        Custom = 200
    }

    /// <summary>
    /// 网络消息结构
    /// </summary>
    public struct NetworkMessage
    {
        public NetworkMessageType Type;
        public int SenderId;
        public double Timestamp;
        public byte[] Data;

        public NetworkMessage(NetworkMessageType type, int senderId, byte[] data)
        {
            Type = type;
            SenderId = senderId;
            Timestamp = Time.GetTicksMsec() / 1000.0;
            Data = data;
        }
    }
}

11.5 核心概念深入讲解

11.5.1 网络架构的演进历程

网络游戏架构经历了从简单到复杂的演进过程。早期的局域网游戏采用纯P2P架构，所有玩家直接互联，这种设计在局域网环境下表现良好，但扩展到互联网时面临诸多挑战。随着游戏规模的扩大，客户端-服务器架构逐渐成为主流，服务器作为权威节点控制游戏状态，客户端仅负责输入和显示。

现代游戏往往采用混合架构。例如，《英雄联盟》使用C/S架构处理核心逻辑，但在语音聊天等功能上使用P2P；《Apex英雄》使用专用服务器，但通过预测和插值技术优化体验。理解这些架构的演变有助于我们为特定游戏类型选择最合适的方案。

11.5.2 网络延迟的本质

网络延迟由多个因素构成：传输延迟（数据在物理介质中的传播时间）、处理延迟（路由器和服务器的处理时间）、排队延迟（数据包在队列中的等待时间）。光速限制了理论最小延迟，从纽约到洛杉矶的往返延迟约为50ms，跨太平洋通信的延迟通常在120-200ms之间。

游戏开发者需要区分感知延迟和实际延迟。客户端预测和本地动画可以让玩家感觉操作是即时的，即使服务器需要100ms才能确认。这种感知优化是多人游戏设计的关键。

11.5.3 带宽与同步频率的权衡

带宽不是无限的资源，特别是对于移动网络和 congested 网络环境。同步频率（Tick Rate）决定了服务器更新状态的频率，常见的选择包括：

20Hz（50ms间隔）：适合回合制和策略游戏
30Hz（33ms间隔）：平衡性能和精度的选择
60Hz（16.6ms间隔）：竞技FPS的标准
120Hz+：格斗游戏和VR应用的需求

更高的频率意味着更低的延迟，但也增加了带宽消耗和服务器负载。Delta压缩和优先级同步可以优化带宽使用。

11.6 实现细节深度分析

11.6.1 ENetMultiplayerPeer 的内部机制

Godot的ENetMultiplayerPeer基于ENet库，这是一个专为游戏设计的高性能网络库。ENet使用UDP协议但提供可靠传输选项，通过以下机制实现：

数据包类型处理：ENet区分三种数据包类型：

可靠有序（Reliable Ordered）：保证送达且按序，适合RPC调用
可靠无序（Reliable Unordered）：保证送达但不保证顺序，适合独立事件
不可靠（Unreliable）：尽力而为，适合高频状态更新

连接管理：ENet使用心跳包检测连接状态，可配置超时时间。当检测到丢包时，会自动重传可靠数据包。这种机制隐藏了网络不稳定的复杂性。

通道系统：ENet支持多通道，允许不同类型的数据并行传输而互不阻塞。例如，可以将聊天消息和游戏状态放在不同通道，避免聊天延迟影响游戏体验。

11.6.2 MultiplayerSynchronizer 的工作原理

MultiplayerSynchronizer通过以下步骤实现自动同步：

属性监控：同步器使用Godot的Property系统监控配置的属性。当属性值变化时，触发同步流程。这种监控是高效的，仅在值变化时才有开销。

序列化：属性值被序列化为紧凑的二进制格式。Godot使用Variant类型系统，可以自动处理基本类型（int、float、Vector3等）和复杂类型（数组、字典）的序列化。

权限控制：通过SetMultiplayerAuthority方法，可以指定哪个对等体有权修改属性。服务器通常拥有所有非玩家实体的权限，玩家只拥有自己角色的权限。

可见性优化：同步器支持基于距离的可见性更新，只有距离玩家一定范围内的实体才会被同步，大幅减少不必要的网络传输。

11.6.3 网络时间的统一

时间同步是网络编程的核心挑战。客户端和服务器的时间必然存在偏差，需要通过算法进行估计和校正：

NTP风格同步：客户端发送带时间戳的请求，服务器返回自己的时间和请求到达时间。客户端通过往返时间（RTT）估算网络延迟，并计算时钟偏移。

平滑校正：直接跳转到正确时间会导致画面卡顿，应使用平滑插值逐步校正。可以维护一个时间偏移量，每帧微调直到与服务器时间一致。

游戏时间 vs 现实时间：游戏逻辑应使用独立于帧率的固定时间步长（Fixed Time Step），确保物理模拟和动画在不同帧率下表现一致。

11.7 最佳实践指南

11.7.1 架构选择决策树

选择合适的网络架构应考虑以下因素：

游戏类型：

FPS/竞技游戏：专用服务器（C/S）
合作游戏：主机模式或C/S
回合制策略：C/S或P2P中继
大型MMO：分布式服务器集群

预算约束：

独立开发者：主机模式或Steam P2P（零服务器成本）
中型团队：云托管专用服务器
大型团队：自建数据中心

目标市场：

电竞市场：专用服务器+反作弊
休闲市场：主机模式+中继服务器
移动市场：优化带宽，支持断线重连

11.7.2 性能优化技巧

带宽优化：

使用位压缩（Bit Packing）减少传输大小
只同步变化的部分（Delta Compression）
降低不重要对象的同步频率
客户端预测减少需要同步的数据量

延迟优化：

使用地理分布的服务器
启用网络质量检测，动态调整策略
实现智能重连机制
使用UDP而非TCP减少头部开销

服务器优化：

使用空间分区（Spatial Partitioning）减少计算量
并行处理独立区域的物理模拟
使用对象池避免频繁内存分配
定期清理不活跃连接

11.7.3 调试与监控

网络调试工具：

使用Godot的Network Profiler监控流量
实现延迟模拟器测试不同网络条件
记录详细的网络日志用于事后分析
可视化网络拓扑和连接状态

关键指标监控：

每秒数据包数（PPS）和字节数
平均延迟和抖动
丢包率和重传率
服务器CPU和内存使用

故障排查流程：

确认基础网络连通性（Ping测试）
检查防火墙和端口配置
分析流量模式识别异常
使用抓包工具（Wireshark）深入分析
逐步隔离问题模块

本章小结：

架构选择：C/S架构适合竞技游戏，P2P适合局域网，混合架构灵活适应不同需求
Godot MultiplayerAPI：提供了MultiplayerPeer、MultiplayerSynchronizer、MultiplayerSpawner三个核心组件
延迟优化：通过预测、插值、压缩等技术减少感知延迟
实现要点：时间同步、权限管理、带宽优化是网络编程的核心挑战

#Godot #开发 #C# #架构 #CSharp #网络