Unity引擎开发：Unity基础入门_Unity网络编程基础v1

在网络编程中，网络架构是指网络系统中各个组件的组织方式和它们之间的交互模式。常见的网络架构有客户端-服务器（Client-Server）模型和对等网络（Peer-to-Peer）模型。除了使用Cmd和Rpc方法，Unity 还支持自定义消息传递。自定义消息可以用来传递特定的数据和指令。定义消息类型在的列表中定义消息类型。发送自定义消息使用方法发送自定义消息。接收自定义消息在服务器上注册消息处理回调

chenlz2007

847人浏览 · 2025-02-17 23:37:17

chenlz2007 · 2025-02-17 23:37:17 发布

Unity网络编程基础

在开发多人在线游戏时，网络编程是一个不可或缺的部分。Unity 提供了多种网络编程的工具和方法，帮助开发者实现玩家之间的互动。本节将详细介绍 Unity 网络编程的基础知识，包括网络架构、通信协议、网络组件的使用以及如何实现基本的网络功能。

网络架构概述

在网络编程中，网络架构是指网络系统中各个组件的组织方式和它们之间的交互模式。常见的网络架构有客户端-服务器（Client-Server）模型和对等网络（Peer-to-Peer）模型。

客户端-服务器模型

客户端-服务器模型是最常见的网络架构之一。在这种模型中，服务器负责管理游戏状态和逻辑，客户端则负责显示和用户输入。客户端通过网络与服务器通信，发送请求并接收响应。

优点

集中管理：服务器可以集中管理游戏的状态和逻辑，确保所有客户端的数据一致性。
扩展性：服务器可以轻松扩展，以支持更多的客户端。
安全性：服务器可以进行安全检查，防止作弊和数据篡改。

缺点

延迟：客户端与服务器之间的通信可能会引入延迟，影响游戏体验。
服务器负载：服务器需要处理所有客户端的请求，可能会成为性能瓶颈。

对等网络模型

对等网络模型中，每个节点既是客户端又是服务器，它们之间直接进行通信。这种模型适用于小型的多人游戏，比如局域网内的多人对战游戏。

优点

低延迟：节点之间的通信延迟较低，适合实时互动。
去中心化：没有单一的服务器，节点之间的通信更灵活。

缺点

数据一致性：每个节点需要自行同步游戏状态，可能会出现数据不一致的问题。
扩展性：随着节点数量的增加，通信复杂度呈指数级增长，难以扩展。
安全性：缺乏中央服务器的管理，容易被攻击和篡改。

通信协议

在网络编程中，通信协议是客户端和服务器之间交换数据的规则。常见的通信协议有 TCP（传输控制协议）和 UDP（用户数据报协议）。

TCP协议

TCP是一种面向连接的协议，提供可靠的数据传输。数据在传输过程中会被分割成数据包，并在接收端重新组装。TCP协议确保数据包按顺序到达，并且会进行错误检测和重传。

优点

可靠性：数据传输可靠，适合需要高可靠性的应用。
流量控制：TCP协议可以自动调整数据传输速率，防止网络拥塞。

缺点

延迟：TCP协议的可靠性机制会引入额外的延迟。
带宽占用：TCP协议的握手和确认机制会占用更多的带宽。

UDP协议

UDP是一种无连接的协议，提供不可靠的数据传输。数据在传输过程中不会被分割成数据包，也不会进行错误检测和重传。UDP协议适合实时性强的应用，比如在线游戏。

优点

低延迟：数据传输速度快，适合实时应用。
带宽占用低：没有握手和确认机制，占用带宽较少。

缺点

不可靠：数据传输不可靠，可能会丢包或乱序。
需要自行管理：开发者需要自行处理数据包的丢失和乱序问题。

Unity网络组件

Unity 提供了多种网络组件，帮助开发者实现网络功能。常见的网络组件有 NetworkManager、NetworkIdentity、NetworkTransform 和 NetworkBehaviour。

NetworkManager

NetworkManager 是 Unity 网络系统的核心组件，负责管理客户端和服务器之间的连接。它提供了启动服务器、连接客户端、管理房间等功能。

使用方法

创建网络管理器：
- 在 Unity 编辑器中，选择 GameObject -> Network -> Network Manager，创建一个 NetworkManager 对象。
- 选中 NetworkManager 对象，在 Inspector 窗口中可以设置各种网络参数，比如最大连接数、网络端口等。

启动服务器：

使用 NetworkManager.StartHost() 方法启动服务器和客户端。


// 启动服务器和客户端

void StartHost()

{

    NetworkManager.singleton.StartHost();

}

连接客户端：

使用 NetworkManager.StartClient() 方法连接到服务器。


// 连接到服务器

void StartClient()

{

    NetworkManager.singleton.StartClient();

}

断开连接：

使用 NetworkManager.StopClient() 方法断开客户端连接。


// 断开客户端连接

void StopClient()

{

    NetworkManager.singleton.StopClient();

}

NetworkIdentity

NetworkIdentity 是 Unity 网络系统中的另一个重要组件，用于标识网络对象。每个需要在网络中同步的 GameObject 都需要添加 NetworkIdentity 组件。

使用方法

添加 NetworkIdentity 组件：
- 选中需要同步的 GameObject，在 Inspector 窗口中点击 Add Component，选择 Network -> Network Identity。
- 通过 isServer 和 isLocalPlayer 属性可以判断对象是否在服务器上或是否为本地玩家。

同步对象：

在服务器上创建并同步对象：


// 在服务器上创建并同步对象

void SpawnObject(GameObject prefab)

{

    GameObject obj = Instantiate(prefab);

    NetworkServer.Spawn(obj);

}

销毁对象：

在服务器上销毁对象：


// 在服务器上销毁对象

void DestroyObject(GameObject obj)

{

    NetworkServer.Destroy(obj);

}

NetworkTransform

NetworkTransform 组件用于在网络中同步 GameObject 的位置和旋转。它会自动将本地对象的变换信息发送到服务器，并由服务器同步到所有客户端。

使用方法

添加 NetworkTransform 组件：
- 选中需要同步变换的 GameObject，在 Inspector 窗口中点击 Add Component，选择 Network -> Network Transform。
- 通过 Send Rate 和 Sync Interval 属性可以调整同步频率和间隔。
同步变换：
- 本地对象的变换信息会自动同步到服务器，服务器再将这些信息同步到所有客户端。

NetworkBehaviour

NetworkBehaviour 是 Unity 网络系统中的基础类，用于在网络中同步脚本的行为。继承自 NetworkBehaviour 的脚本可以使用 Cmd、Rpc 和 SyncVar 等方法进行网络同步。

使用方法

创建网络脚本：

创建一个继承自 NetworkBehaviour 的脚本：


using UnityEngine;

using UnityEngine.Networking;



public class PlayerController : NetworkBehaviour

{

    // 同步变量

    [SyncVar]

    public float health;



    // 客户端调用，服务器执行

    [Command]

    public void CmdTakeDamage(float amount)

    {

        health -= amount;

        if (health <= 0)

        {

            // 服务器上的死亡逻辑

            Die();

        }

    }



    // 服务器调用，所有客户端执行

    [ClientRpc]

    public void RpcTakeDamage(float amount)

    {

        health -= amount;

    }



    // 本地死亡逻辑

    void Die()

    {

        // 例如：销毁玩家对象

        Destroy(gameObject);

    }

}

使用同步变量：
- 使用 [SyncVar] 属性声明同步变量，这些变量会在客户端和服务器之间自动同步。
```
[SyncVar]

public float health;
```

使用命令方法：

使用 [Command] 属性声明命令方法，这些方法只能在客户端调用，服务器上执行。


[Command]

public void CmdTakeDamage(float amount)

{

    health -= amount;

    if (health <= 0)

    {

        // 服务器上的死亡逻辑

        Die();

    }

}

使用客户端调用方法：
- 使用 [ClientRpc] 属性声明客户端调用方法，这些方法由服务器调用，所有客户端执行。
```
[ClientRpc]

public void RpcTakeDamage(float amount)

{

    health -= amount;

}
```

实现基本的网络功能

在本节中，我们将通过一个简单的例子来实现基本的网络功能。这个例子将展示如何创建一个多人在线的射击游戏，玩家可以通过网络进行互动。

游戏对象的网络同步

创建玩家对象：
- 创建一个 GameObject 作为玩家对象，并添加 NetworkIdentity 和 NetworkTransform 组件。

编写玩家控制脚本：

创建一个继承自 NetworkBehaviour 的脚本 PlayerController，用于控制玩家的移动和射击。


using UnityEngine;

using UnityEngine.Networking;



public class PlayerController : NetworkBehaviour

{

    [SyncVar]

    public float health = 100f;



    public float moveSpeed = 5f;

    public float rotationSpeed = 100f;



    private CharacterController characterController;



    void Start()

    {

        characterController = GetComponent<CharacterController>();

    }



    void Update()

    {

        if (isLocalPlayer)

        {

            HandleMovement();

            HandleShooting();

        }

    }



    void HandleMovement()

    {

        float horizontal = Input.GetAxis("Horizontal");

        float vertical = Input.GetAxis("Vertical");



        Vector3 movement = new Vector3(horizontal, 0f, vertical);

        movement = transform.TransformDirection(movement);

        movement *= moveSpeed * Time.deltaTime;



        characterController.Move(movement);

    }



    void HandleShooting()

    {

        if (Input.GetButton("Fire1"))

        {

            CmdShoot();

        }

    }



    [Command]

    void CmdShoot()

    {

        // 服务器上的射击逻辑

        // 例如：创建子弹对象

        GameObject bullet = Instantiate(bulletPrefab, transform.position, transform.rotation);

        bullet.GetComponent<Rigidbody>().velocity = transform.forward * bulletSpeed;



        // 同步子弹对象

        NetworkServer.Spawn(bullet);

    }



    [ClientRpc]

    void RpcTakeDamage(float amount)

    {

        health -= amount;

    }



    void Die()

    {

        // 例如：销毁玩家对象

        Destroy(gameObject);

    }

}

子弹对象的网络同步

创建子弹对象：
- 创建一个 GameObject 作为子弹对象，并添加 NetworkIdentity 和 NetworkTransform 组件。

编写子弹控制脚本：

创建一个继承自 NetworkBehaviour 的脚本 BulletController，用于控制子弹的移动和销毁。


using UnityEngine;

using UnityEngine.Networking;



public class BulletController : NetworkBehaviour

{

    public float bulletSpeed = 10f;

    public float bulletLifetime = 2f;



    void Update()

    {

        if (isServer)

        {

            // 服务器上的子弹移动逻辑

            transform.Translate(Vector3.forward * bulletSpeed * Time.deltaTime);



            // 检查子弹是否超时

            bulletLifetime -= Time.deltaTime;

            if (bulletLifetime <= 0)

            {

                CmdDestroyBullet();

            }

        }

    }



    void OnCollisionEnter(Collision collision)

    {

        if (isServer)

        {

            // 检查碰撞对象是否为玩家

            PlayerController player = collision.gameObject.GetComponent<PlayerController>();

            if (player != null)

            {

                player.CmdTakeDamage(10f);

            }



            // 销毁子弹

            CmdDestroyBullet();

        }

    }



    [Command]

    void CmdDestroyBullet()

    {

        NetworkServer.Destroy(gameObject);

    }

}

网络管理器的配置

配置网络管理器：
- 选中 NetworkManager 对象，在 Inspector 窗口中配置网络参数。
- 设置 Player Prefab 为玩家对象的预制体。
- 设置 Network Address 为服务器地址，Network Port 为服务器端口。

启动网络管理器：

在游戏场景中创建一个用于启动网络管理器的按钮，并编写相应的脚本。


using UnityEngine;

using UnityEngine.UI;



public class NetworkManagerUI : MonoBehaviour

{

    public Button hostButton;

    public Button clientButton;



    void Start()

    {

        hostButton.onClick.AddListener(OnHostButtonClicked);

        clientButton.onClick.AddListener(OnClientButtonClicked);

    }



    void OnHostButtonClicked()

    {

        NetworkManager.singleton.StartHost();

    }



    void OnClientButtonClicked()

    {

        NetworkManager.singleton.StartClient();

    }

}

网络状态的检测和处理

检测网络连接状态：

使用 NetworkManager.singleton.IsClient 和 NetworkManager.singleton.IsServer 属性检测当前对象的网络连接状态。


using UnityEngine;

using UnityEngine.Networking;



public class NetworkStatus : MonoBehaviour

{

    void Update()

    {

        if (NetworkManager.singleton.IsClient)

        {

            Debug.Log("当前为客户端");

        }



        if (NetworkManager.singleton.IsServer)

        {

            Debug.Log("当前为服务器");

        }

    }

}

处理网络错误：

使用 NetworkManager.singleton.OnClientDisconnect 和 NetworkManager.singleton.OnServerDisconnect 事件处理网络断开连接的情况。


using UnityEngine;

using UnityEngine.Networking;



public class NetworkDisconnectHandler : MonoBehaviour

{

    void OnClientDisconnect(NetworkConnection conn)

    {

        Debug.Log("客户端断开连接: " + conn.connectionId);

    }



    void OnServerDisconnect(NetworkConnection conn)

    {

        Debug.Log("服务器断开连接: " + conn.connectionId);

    }



    void Start()

    {

        NetworkManager.singleton.OnClientDisconnectCallback += OnClientDisconnect;

        NetworkManager.singleton.OnServerDisconnectCallback += OnServerDisconnect;

    }



    void OnDestroy()

    {

        NetworkManager.singleton.OnClientDisconnectCallback -= OnClientDisconnect;

        NetworkManager.singleton.OnServerDisconnectCallback -= OnServerDisconnect;

    }

}

进阶网络功能

在掌握了基本的网络功能后，我们可以进一步实现一些进阶的网络功能，比如断线重连、自定义消息传递和网络状态同步。

断线重连

断线重连是指在网络连接断开后，客户端能够重新连接到服务器。Unity 提供了 NetworkManager.singleton.Reconnect 方法来实现断线重连。

检测网络断开：

在网络断开时，调用 Reconnect 方法重新连接。


using UnityEngine;

using UnityEngine.Networking;



public class ReconnectHandler : MonoBehaviour

{

    void OnClientDisconnect(NetworkConnection conn)

    {

        Debug.Log("客户端断开连接: " + conn.connectionId);

        NetworkManager.singleton.Reconnect();

    }



    void Start()

    {

        NetworkManager.singleton.OnClientDisconnectCallback += OnClientDisconnect;

    }



    void OnDestroy()

    {

        NetworkManager.singleton.OnClientDisconnectCallback -= OnClientDisconnect;

    }

}

自定义消息传递

除了使用 Cmd 和 Rpc 方法，Unity 还支持自定义消息传递。自定义消息可以用来传递特定的数据和指令。

定义消息类型：

在 NetworkManager 的 CustomMessages 列表中定义消息类型。


using UnityEngine;

using UnityEngine.Networking;



[MessageBase]

public class CustomMessage : MessageBase

{

    public string message;

}



public class ChatMessage : CustomMessage

{

    public string chatText;

}

发送自定义消息：

使用 NetworkClient.Send 方法发送自定义消息。


using UnityEngine;

using UnityEngine.Networking;



public class ChatSender : NetworkBehaviour

{

    public string chatText;



    void Update()

    {

        if (isLocalPlayer && Input.GetKeyDown(KeyCode.Return))

        {

            ChatMessage msg = new ChatMessage();

            msg.chatText = chatText;



            NetworkClient.Send(msg);

        }

    }

}

接收自定义消息：

在服务器上注册消息处理回调函数。


using UnityEngine;

using UnityEngine.Networking;



public class ChatReceiver : NetworkBehaviour

{

    void OnStartServer()

    {

        NetworkServer.RegisterHandler<ChatMessage>(OnChatMessageReceived);

    }



    void OnChatMessageReceived(NetworkMessage netMsg)

    {

        ChatMessage msg = netMsg.ReadMessage<ChatMessage>();



        // 处理聊天消息

        Debug.Log("收到聊天消息: " + msg.chatText);

    }

}

网络状态同步

在网络游戏中，同步游戏状态是非常重要的。除了使用 SyncVar，我们还可以使用 NetworkBehaviour 的 OnStartAuthority 和 OnStopAuthority 方法来同步游戏状态。

同步游戏状态：

在 OnStartAuthority 和 OnStopAuthority 方法中处理游戏状态的同步。


using UnityEngine;

using UnityEngine.Networking;



public class GameStateSync : NetworkBehaviour

{

    [SyncVar]

    public bool isAlive = true;



    void OnStartAuthority()

    {

        // 当客户端获得控制权时，同步游戏状态

        if (isAlive)

        {

            // 例如：播放重生动画

            PlayRespawnAnimation();

        }

        else

        {

            // 例如：播放死亡动画

            PlayDeathAnimation();

        }

    }



    void OnStopAuthority()

    {

        // 当客户端失去控制权时，处理相关逻辑

    }



    void PlayRespawnAnimation()

    {

        // 播放重生动画的逻辑

    }



    void PlayDeathAnimation()

    {

        // 播放死亡动画的逻辑

    }

}

网络优化

在网络编程中，优化网络性能是非常重要的。以下是一些常见的网络优化技巧：

减少网络数据传输

使用压缩：

使用 NetworkWriter 和 NetworkReader 的压缩功能来减少数据传输量。


using UnityEngine;

using UnityEngine.Networking;



public class CompressedData : NetworkBehaviour

{

    [SyncVar(hook = nameof(OnDataReceived))]

    public byte[] compressedData;



    void OnDataReceived(byte[] newData)

    {

        // 解压缩数据

        string data = System.Text.Encoding.UTF8.GetString(newData);

        Debug.Log("收到解压缩数据: " + data);

    }



    [Command]

    void CmdSendCompressedData(string data)

    {

        // 压缩数据

        byte[] compressedData = System.Text.Encoding.UTF8.GetBytes(data);

        this.compressedData = compressedData;

    }

}

减少同步频率：

通过调整 NetworkTransform 和自定义同步变量的同步频率，减少不必要的网络数据传输。


using UnityEngine;

using UnityEngine.Networking;



public class PlayerController : NetworkBehaviour

{

    [SyncVar(hook = nameof(OnHealthChanged), sendInterval = 0.5f)]

    public float health = 100f;



    void OnHealthChanged(float oldHealth, float newHealth)

    {

        // 处理健康值变化

        Debug.Log("健康值从 " + oldHealth + " 变为 " + newHealth);

    }



    [Command]

    void CmdTakeDamage(float amount)

    {

        health -= amount;

        if (health <= 0)

        {

            Die();

        }

    }



    [ClientRpc]

    void RpcTakeDamage(float amount)

    {

        health -= amount;

    }



    void Die()

    {

        // 例如：销毁玩家对象

        Destroy(gameObject);

    }

}

优化网络延迟

使用预测和插值：

预测和插值技术可以减少网络延迟带来的影响。预测技术在客户端上预先计算对象的未来状态，而插值技术则在客户端上平滑过渡对象的当前状态和服务器状态。


using UnityEngine;

using UnityEngine.Networking;



public class PlayerController : NetworkBehaviour

{

    [SyncVar(hook = nameof(OnPositionChanged))]

    public Vector3 syncPosition;



    private Vector3 lastPosition;

    private Vector3 targetPosition;

    private float lerpTime = 0f;



    void OnPositionChanged(Vector3 oldPosition, Vector3 newPosition)

    {

        lastPosition = oldPosition;

        targetPosition = newPosition;

        lerpTime = 0f;

    }



    void Update()

    {

        if (isLocalPlayer)

        {

            HandleMovement();

            HandleShooting();

        }

        else

        {

            // 插值同步位置

            if (lerpTime < 1f)

            {

                transform.position = Vector3.Lerp(lastPosition, targetPosition, lerpTime);

                lerpTime += Time.deltaTime * 2f; // 调整插值速度

            }

            else

            {

                transform.position = targetPosition;

            }

        }

    }



    void HandleMovement()

    {

        float horizontal = Input.GetAxis("Horizontal");

        float vertical = Input.GetAxis("Vertical");



        Vector3 movement = new Vector3(horizontal, 0f, vertical);

        movement = transform.TransformDirection(movement);

        movement *= moveSpeed * Time.deltaTime;



        characterController.Move(movement);



        // 同步位置

        syncPosition = transform.position;

    }



    void HandleShooting()

    {

        if (Input.GetButton("Fire1"))

        {

            CmdShoot();

        }

    }



    [Command]

    void CmdShoot()

    {

        // 服务器上的射击逻辑

        // 例如：创建子弹对象

        GameObject bullet = Instantiate(bulletPrefab, transform.position, transform.rotation);

        bullet.GetComponent<Rigidbody>().velocity = transform.forward * bulletSpeed;



        // 同步子弹对象

        NetworkServer.Spawn(bullet);

    }

}

优化带宽使用

使用网络视图：

NetworkIdentity 组件的 LocalPlayerAuthority 属性可以控制网络对象的同步范围，减少不必要的带宽使用。


using UnityEngine;

using UnityEngine.Networking;



public class PlayerController : NetworkBehaviour

{

    [SyncVar(hook = nameof(OnHealthChanged))]

    public float health = 100f;



    [SyncVar(hook = nameof(OnPositionChanged))]

    public Vector3 syncPosition;



    public bool hasAuthority;



    void OnHealthChanged(float oldHealth, float newHealth)

    {

        // 处理健康值变化

        Debug.Log("健康值从 " + oldHealth + " 变为 " + newHealth);

    }



    void OnPositionChanged(Vector3 oldPosition, Vector3 newPosition)

    {

        // 处理位置变化

        Debug.Log("位置从 " + oldPosition + " 变为 " + newPosition);

    }



    void Update()

    {

        if (isLocalPlayer)

        {

            HandleMovement();

            HandleShooting();

        }

        else if (hasAuthority)

        {

            // 插值同步位置

            if (lerpTime < 1f)

            {

                transform.position = Vector3.Lerp(lastPosition, targetPosition, lerpTime);

                lerpTime += Time.deltaTime * 2f; // 调整插值速度

            }

            else

            {

                transform.position = targetPosition;

            }

        }

    }



    void HandleMovement()

    {

        float horizontal = Input.GetAxis("Horizontal");

        float vertical = Input.GetAxis("Vertical");



        Vector3 movement = new Vector3(horizontal, 0f, vertical);

        movement = transform.TransformDirection(movement);

        movement *= moveSpeed * Time.deltaTime;



        characterController.Move(movement);



        // 同步位置

        syncPosition = transform.position;

    }



    void HandleShooting()

    {

        if (Input.GetButton("Fire1"))

        {

            CmdShoot();

        }

    }



    [Command]

    void CmdShoot()

    {

        // 服务器上的射击逻辑

        // 例如：创建子弹对象

        GameObject bullet = Instantiate(bulletPrefab, transform.position, transform.rotation);

        bullet.GetComponent<Rigidbody>().velocity = transform.forward * bulletSpeed;



        // 同步子弹对象

        NetworkServer.Spawn(bullet);

    }

}

使用网络分组：

将网络对象分组，只同步相关的对象，减少带宽使用。


using UnityEngine;

using UnityEngine.Networking;



public class NetworkGroup : NetworkBehaviour

{

    public GameObject[] objectsToSync;



    void Start()

    {

        if (isServer)

        {

            foreach (GameObject obj in objectsToSync)

            {

                NetworkServer.Spawn(obj, connectionToClient);

            }

        }

    }

}

优化网络安全性

使用网络身份验证：

在客户端连接服务器时进行身份验证，确保只有合法的客户端可以连接。


using UnityEngine;

using UnityEngine.Networking;



public class NetworkAuthenticator : NetworkManager

{

    public override void OnServerConnect(NetworkConnection conn)

    {

        // 发送身份验证请求

        conn.Send(new AuthRequestMessage());



        base.OnServerConnect(conn);

    }



    public override void OnServerAddPlayer(NetworkConnection conn, short playerControllerId)

    {

        // 检查身份验证结果

        if (conn.isAuthenticated)

        {

            base.OnServerAddPlayer(conn, playerControllerId);

        }

        else

        {

            conn.Disconnect();

        }

    }



    public void OnAuthRequestReceived(NetworkMessage netMsg)

    {

        AuthRequestMessage msg = netMsg.ReadMessage<AuthRequestMessage>();



        // 检查身份验证信息

        if (IsValidUser(msg.username, msg.password))

        {

            netMsg.conn.isAuthenticated = true;

            netMsg.conn.Send(new AuthSuccessMessage());

        }

        else

        {

            netMsg.conn.Send(new AuthFailureMessage());

        }

    }



    bool IsValidUser(string username, string password)

    {

        // 检查用户名和密码的合法性

        return username == "validUser" && password == "validPassword";

    }

}



[MessageBase]

public class AuthRequestMessage : MessageBase

{

    public string username;

    public string password;

}



[MessageBase]

public class AuthSuccessMessage : MessageBase

{

}



[MessageBase]

public class AuthFailureMessage : MessageBase

{

}

使用网络加密：

对网络数据进行加密，防止数据被窃取或篡改。


using UnityEngine;

using UnityEngine.Networking;



public class NetworkEncryptor : MonoBehaviour

{

    void OnStartServer()

    {

        NetworkServer.RegisterHandler<CustomMessage>(OnCustomMessageReceived);

    }



    void OnCustomMessageReceived(NetworkMessage netMsg)

    {

        CustomMessage msg = netMsg.ReadMessage<CustomMessage>();



        // 解密数据

        string decryptedData = DecryptData(msg.compressedData);



        // 处理解密后的数据

        Debug.Log("收到解密数据: " + decryptedData);

    }



    void OnStartClient()

    {

        NetworkClient.RegisterHandler<CustomMessage>(OnCustomMessageReceived);

    }



    [Command]

    void CmdSendEncryptedData(string data)

    {

        // 加密数据

        byte[] encryptedData = EncryptData(data);



        CustomMessage msg = new CustomMessage();

        msg.compressedData = encryptedData;



        NetworkClient.Send(msg);

    }



    byte[] EncryptData(string data)

    {

        // 加密逻辑

        return System.Text.Encoding.UTF8.GetBytes(data);

    }



    string DecryptData(byte[] encryptedData)

    {

        // 解密逻辑

        return System.Text.Encoding.UTF8.GetString(encryptedData);

    }

}

网络调试

在网络编程中，调试是非常重要的一步。Unity 提供了一些工具和方法来帮助开发者进行网络调试。

使用 Unity 的网络调试工具

Network Profiler：
- Unity 的 Network Profiler 可以帮助开发者监控网络性能，包括带宽使用、延迟等。
- 在 Unity 编辑器中，选择 Window -> Analysis -> Network Profiler 打开网络调试工具。

日志输出：

使用 Debug.Log 和 Debug.LogError 输出网络调试信息，帮助定位问题。


using UnityEngine;

using UnityEngine.Networking;



public class NetworkDebugger : MonoBehaviour

{

    void OnStartServer()

    {

        Debug.Log("服务器启动");

    }



    void OnStartClient()

    {

        Debug.Log("客户端启动");

    }



    void OnClientDisconnect(NetworkConnection conn)

    {

        Debug.LogError("客户端断开连接: " + conn.connectionId);

    }



    void OnServerDisconnect(NetworkConnection conn)

    {

        Debug.LogError("服务器断开连接: " + conn.connectionId);

    }

}

使用自定义调试工具

网络状态显示：

在游戏界面上显示网络状态信息，比如延迟、带宽使用等。


using UnityEngine;

using UnityEngine.UI;



public class NetworkStatusDisplay : MonoBehaviour

{

    public Text latencyText;

    public Text bandwidthText;



    void Update()

    {

        if (NetworkManager.singleton != null)

        {

            latencyText.text = "延迟: " + NetworkManager.singleton.networkLatency * 1000 + " ms";

            bandwidthText.text = "带宽: " + NetworkManager.singleton.networkSendQueueSize + " bytes/s";

        }

    }

}

网络事件日志：

记录网络事件日志，方便后续分析。


using UnityEngine;

using UnityEngine.Networking;



public class NetworkEventLogger : MonoBehaviour

{

    void OnStartServer()

    {

        Debug.Log("服务器启动");

    }



    void OnStartClient()

    {

        Debug.Log("客户端启动");

    }



    void OnClientDisconnect(NetworkConnection conn)

    {

        Debug.LogError("客户端断开连接: " + conn.connectionId);

        RecordEvent("客户端断开连接: " + conn.connectionId);

    }



    void OnServerDisconnect(NetworkConnection conn)

    {

        Debug.LogError("服务器断开连接: " + conn.connectionId);

        RecordEvent("服务器断开连接: " + conn.connectionId);

    }



    void RecordEvent(string message)

    {

        // 记录日志到文件或数据库

        System.IO.File.AppendAllText("network_events.log", message + "\n");

    }

}

总结

通过本节的学习，我们了解了 Unity 网络编程的基础知识，包括网络架构、通信协议、网络组件的使用以及如何实现基本的网络功能。此外，我们还学习了一些进阶的网络功能，比如断线重连、自定义消息传递和网络状态同步。在网络优化方面，我们讨论了减少网络数据传输、优化网络延迟、优化带宽使用和网络安全性。最后，我们介绍了网络调试的方法，包括使用 Unity 的网络调试工具和自定义调试工具。

希望这些内容能帮助你在 Unity 中实现高效的多人在线游戏。如果你有任何问题或需要进一步的帮助，欢迎查阅 Unity 官方文档或寻求社区的支持。
在这里插入图片描述