【游戏开发实战】Unity使用Socket通信实现简单的多人聊天室（万字详解 | 网络 | TCP | 通信 | Mirror | Networking）

太过爱你忘了你带给我的痛 2022-08-30 04:21 243阅读 0赞

### 文章目录 ###

*   *   *  一、前言
         *  二、简单的Socket通信：多人聊天室
         *   *  1、服务端：python代码
             *   *  1.1、import socket
                 *  1.2、构造socket对象
                 *  1.3、绑定/监听端口
                 *  1.3、监听客户端连接
                 *  1.4、接收客户端socket消息
                 *  1.5、多线程
                 *  1.6、完整代码：game\_server.py
             *  2、客户端：Unity
             *   *  2.1、创建工程，搭建场景
                 *  2.2、Socket封装：ClientSocket.cs
                 *   *  2.2.1、构造Socket对象
                     *  2.2.2、连接服务器
                     *  2.2.3、断开连接
                     *  2.2.4、发送消息
                     *  2.2.5、接收服务端消息
                     *  2.2.6、完整代码：ClientSocket.cs
                 *  2.3、UI交互：TestPanel.cs
                 *   *  2.3.1、定义变量
                     *  2.3.2、登录服务端
                     *  2.3.3、断开连接
                     *  2.3.4、发送消息
                     *  2.3.5、接收消息
                     *  2.3.6、完整代码：TestPanel.cs
                 *  2.4、挂脚本，赋值成员对象
             *  3、打包客户端
             *  4、运行测试
             *  5、工程源码
         *  三、拓展：Mirror Networking
         *   *  1、局域网多人联机Demo的救星：Mirror
             *  2、关于Mirror
             *  3、Mirror插件下载
             *  4、Mirror 案例测试：多人坦克对战
             *  5、Mirror 案例讲解：多人坦克对战
             *   *  5.1、NetworkManager物体
                 *   *  5.1.1、NetworkManager组件
                     *  5.1.2、NetworkManagerHUD组件
                     *  5.1.3、KcpTransport组件
                 *  5.2、地面（带导航功能）
                 *   *  5.2.1、创建Plane
                     *  5.2.2、导航烘焙：Navigation
                 *  5.3、坦克生成点：NewworkStartPosition
                 *  5.4、坦克身上的组件
                 *   *  5.4.1、坦克预设
                     *  5.4.2、NavMeshAgent组件
                     *  5.4.4、Animator组件
                     *  5.4.5、NetworkTransform组件
                     *  5.4.6、NetworkIdentity组件
                     *  5.4.7、NetworkBehaviour组件: Tank
                 *  5.5、赋值PlayerPrefab
                 *  5.6、炮弹预设
                 *  5.7、坦克脚本：Tank.cs
                 *  5.8、Transform的网络同步：NetworkTransform.cs
                 *  5.9、炮弹脚本：Projectile.cs
         *  四、完毕

### 一、前言 ###

嗨，大家好，我是新发。  
事情是这样的，上次有同学问我能不能出一期 **网络** 相关的教程，  
![在这里插入图片描述][20210720100330896.png]  
然而我眼花看错了，看成了 **网格**，我还专门写了一篇文章：[《【游戏开发进阶】Unity网格探险之旅（Mesh | 动态合批 | 骨骼动画 | 蒙皮 ）》][Unity_Mesh _ _ _ _ _ _]  
直到有同学在评论里提醒我，真是尴尬…  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70]  
嘛，没事，今天就补上，写一篇 **网络** 相关文章。

我准备做个例子，使用`.Net`原生的`Socket`模块来实现简单的多人聊天室功能。  
话不多说，我们开始吧~

### 二、简单的Socket通信：多人聊天室 ###

`Unity`中我们要实现网络通信，可以使用`.Net`的`Socket`模块来实现。

为了演示，我就用`python`写个简单的服务端，用`Unity`作为客户端。  
先画个 **流程图**。

服务端（`python`）流程图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 1]  
客户端（`Unity`）流程图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 2]

#### 1、服务端：python代码 ####

新建一个`python`脚本：`game_server.py`，如下  
![在这里插入图片描述][20210720103158175.png]

##### 1.1、import socket #####

因为我们要使用`socket`，所以先引入`socket`模块：

import socket

##### 1.2、构造socket对象 #####

g_socket_server = None
    g_socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

关于`socket`的`python`函数原型可以使用`help(socket)`查看，  
![在这里插入图片描述][20210721085329951.png]  
第一个参数是`socket domains`（通信协议族），有两种类型：`AF_UNIX`、`AF_INET`，它们的区别：

<table> 
 <thead> 
  <tr> 
   <th align="left">通信协议族</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">AF_UNIX</td> 
   <td align="left">本机通信；另，它只能够用于单一的<code>Unix</code>系统进程间通信，不能在<code>Windows</code>系统中使用</td> 
  </tr> 
  <tr> 
   <td align="left">AF_INET</td> 
   <td align="left"><code>TCP/IP</code>通信</td> 
  </tr> 
 </tbody> 
</table>

第二个参数是`socket type`（套接字类型），有`SOCKET_STREAM`、`SOCK_DGRAM`、`SOCK_RAW`三种，

<table> 
 <thead> 
  <tr> 
   <th align="left">套接字类型</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">SOCKET_STREAM</td> 
   <td align="left">流式套接字，基于<code>TCP</code>通信，数据有保障（即能保证数据正确传送到对方），多用于资料（如文件）传送</td> 
  </tr> 
  <tr> 
   <td align="left">SOCK_DGRAM</td> 
   <td align="left">数据报套接字，基于<code>UDP</code>通信，数据是无保障的 ， 主要用于在网络上发广播信息</td> 
  </tr> 
  <tr> 
   <td align="left">SOCK_RAW</td> 
   <td align="left">原始套接字，普通的套接字无法处理<code>ICMP</code>、<code>IGMP</code>等网络报文，而<code>SOCK_RAW</code>可以；<code>SOCK_RAW</code>也可以处理特殊的<code>IPv4</code>报文；此外，利用原始套接字，可以通过<code>IP_HDRINCL</code>套接字选项由用户构造IP头</td> 
  </tr> 
 </tbody> 
</table>

##### 1.3、绑定/监听端口 #####

ADDRESS = ('127.0.0.1', 8712)
    g_socket_server.bind(ADDRESS)
    g_socket_server.listen(5)

##### 1.3、监听客户端连接 #####

client, info = g_socket_server.accept()

##### 1.4、接收客户端socket消息 #####

data = client.recv(1024)
    msg = data.decode(encoding='utf8')

使用`json`对消息字段进行解析：

import json
    
    jd = json.loads(jsonstr)
    protocol = jd['protocol']
    uname = jd['uname']
    msg = jd['msg']

##### 1.5、多线程 #####

由于监听客户端（`socket.accept`）和接收消息（`socket.recv`）都是 **阻塞** 的，为了不阻塞主线程，我们使用 **子线程** 来处理。  
创建不带参数的线程：

thread = Thread(target=thread_func)
    thread.start()
    
    def thread_func():
    	pass

创建带参数的线程：

thread = Thread(target=thread_func, args=(p1, p2, p3))
    thread.start()
    
    def thread_func(p1, p2, p3):
    	pass

##### 1.6、完整代码：game\_server.py #####

最终，`game_server.py`完整代码如下：

'''
    作者：林新发，博客：https://blog.csdn.net/linxinfa
    功能：简单的Socket通信，聊天室服务端
    python版本：3.6.4
    '''
    import socket  # 导入 socket 模块
    from threading import Thread
    import time
    import json
    
    ADDRESS = ('127.0.0.1', 8712)  # 绑定地址
    g_socket_server = None  # 负责监听的socket
    g_conn_pool = {
        }  # 连接池
    
    def accept_client():
        global g_socket_server
        g_socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
        g_socket_server.bind(ADDRESS)
        g_socket_server.listen(5)  # 最大等待数（有很多人理解为最大连接数，其实是错误的）
        print("server start，wait for client connecting...")
        '''
        接收新连接
        '''
        while True:
            client, info = g_socket_server.accept()  # 阻塞，等待客户端连接
            # 给每个客户端创建一个独立的线程进行管理
            thread = Thread(target=message_handle, args=(client, info))
            thread.setDaemon(True)
            thread.start()
     
     
    def message_handle(client, info):
        '''
        消息处理
        '''
        handle_id = info[1]
        # 缓存客户端socket对象
        g_conn_pool[handle_id] = client
        while True:
            try:
                data = client.recv(1024)
                jsonstr = data.decode(encoding='utf8')
                jd = json.loads(jsonstr)
                protocol = jd['protocol']
                uname = jd['uname']
                if 'login' == protocol:
                    print('on client login, ' + uname)
                     # 转发给所有客户端
                    for u in g_conn_pool:
                        g_conn_pool[u].sendall((uname + " 进入了房间").encode(encoding='utf8'))
                elif 'chat' == protocol:
                    # 收到客户端聊天消息
                    print(uname + ":" + jd['msg'])
                    # 转发给所有客户端
                    for key in g_conn_pool:
                        g_conn_pool[key].sendall((uname + " : " + jd['msg']).encode(encoding='utf8'))
            except Exception as e:
                remove_client(handle_id)
                break
    
    def remove_client(handle_id):
        client = g_conn_pool[handle_id]
        if None != client:
            client.close()
            g_conn_pool.pop(handle_id)
            print("client offline: " + str(handle_id))
    
    
    if __name__ == '__main__':
        # 新开一个线程，用于接收新连接
        thread = Thread(target=accept_client)
        thread.setDaemon(True)
        thread.start()
        # 主线程逻辑
        while True:
            time.sleep(0.1)

#### 2、客户端：Unity ####

##### 2.1、创建工程，搭建场景 #####

新建一个`Unity`工程，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 3]  
使用`UGUI`简单搭建一下界面，如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 4]  
养成好习惯，界面保存为预设：`TestPanel.prefab`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 5]

##### 2.2、Socket封装：ClientSocket.cs #####

我们先封装一个`ClientSocket.cs`，实现`Socket`的创建、连接和收发消息等功能。

###### 2.2.1、构造Socket对象 ######

// using System.Net.Sockets;
    
    Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

###### 2.2.2、连接服务器 ######

socket.Connect(host, port);

###### 2.2.3、断开连接 ######

socket.Shutdown(SocketShutdown.Both);
    socket.Close();
    socket = null;

###### 2.2.4、发送消息 ######

// byte[] bytes 你的消息的字节数组
    NetworkStream netstream = new NetworkStream(socket);
    netstream.Write(bytes, 0, bytes.Length);

###### 2.2.5、接收服务端消息 ######

// 回调函数对象
    AsyncCallback recvCb = new AsyncCallback(RecvCallBack);
    // 数据缓存
    byte[] recvBuff = new byte[0x4000];
    // 消息队列
    Queue<string> msgQueue = new Queue<string>();
    
    // 每帧调用此方法
    socket.BeginReceive(recvBuff, 0, recvBuff.Length, SocketFlags.None, recvCb, this);
    
    // 接收消息回调函数
    private void RecvCallBack(IAsyncResult ar)
    {
        
    	var len = socket.EndReceive(ar);
        byte[] msg = new byte[len];
        Array.Copy(m_recvBuff, msg, len);
        var msgStr = System.Text.Encoding.UTF8.GetString(msg);
        // 将消息塞入队列中
        msgQueue.Enqueue(msgStr);
    }
    
    // 从消息队列中取出消息（供外部调用）
    public string GetMsgFromQueue()
    {
        
        if (msgQueue.Count > 0)
            return msgQueue.Dequeue();
        return null;
    }

###### 2.2.6、完整代码：ClientSocket.cs ######

最终，`ClientSocket.cs`完整代码如下：

/*
     * Socket封装
     * 作者：林新发 博客：https://blog.csdn.net/linxinfa
    */
    
    using System;
    using System.Net.Sockets;
    using UnityEngine;
    using System.Collections.Generic;
    
    public class ClientSocket
    {
        
        private Socket init()
        {
        
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            // 接收的消息数据包大小限制为 0x4000 byte, 即16KB
            m_recvBuff = new byte[0x4000];
            m_recvCb = new AsyncCallback(RecvCallBack);
            return clientSocket;
        }
    
        /// <summary>
        /// 连接服务器
        /// </summary>
        /// <param name="host">ip地址</param>
        /// <param name="port">端口号</param>
        public void Connect(string host, int port)
        {
        
            if (m_socket == null)
                m_socket = init();
            try
            {
        
                Debug.Log("connect: " + host + ":" + port);
                m_socket.SendTimeout = 3;
                m_socket.Connect(host, port);
                connected = true;
    
            }
            catch (Exception ex)
            {
        
                Debug.LogError(ex);
            }
        }
    
        /// <summary>
        /// 发送消息
        /// </summary>
        public void SendData(byte[] bytes)
        {
        
            NetworkStream netstream = new NetworkStream(m_socket);
            netstream.Write(bytes, 0, bytes.Length);
        }
    
        /// <summary>
        /// 尝试接收消息（每帧调用）
        /// </summary>
        public void BeginReceive()
        {
        
            m_socket.BeginReceive(m_recvBuff, 0, m_recvBuff.Length, SocketFlags.None, m_recvCb, this);
        }
    
        /// <summary>
        /// 当收到服务器的消息时会回调这个函数
        /// </summary>
        private void RecvCallBack(IAsyncResult ar)
        {
        
            var len = m_socket.EndReceive(ar);
            byte[] msg = new byte[len];
            Array.Copy(m_recvBuff, msg, len);
            var msgStr = System.Text.Encoding.UTF8.GetString(msg);
            // 将消息塞入队列中
            m_msgQueue.Enqueue(msgStr);
            // 将buffer清零
            for (int i = 0; i < m_recvBuff.Length; ++i)
            {
        
                m_recvBuff[i] = 0;
            }
        }
    
        /// <summary>
        /// 从消息队列中取出消息
        /// </summary>
        /// <returns></returns>
        public string GetMsgFromQueue()
        {
        
            if (m_msgQueue.Count > 0)
                return m_msgQueue.Dequeue();
            return null;
        }
    
        /// <summary>
        /// 关闭Socket
        /// </summary>
        public void CloseSocket()
        {
        
            Debug.Log("close socket");
            try
            {
        
                m_socket.Shutdown(SocketShutdown.Both);
                m_socket.Close();
            }
            catch(Exception e)
            {
        
                //Debug.LogError(e);
            }
            finally
            {
        
                m_socket = null;
                connected = false;
            }
        }
    
    
        public bool connected = false;
    
        private byte[] m_recvBuff;
        private AsyncCallback m_recvCb;
        private Queue<string> m_msgQueue = new Queue<string>();
        private Socket m_socket;
    }

##### 2.3、UI交互：TestPanel.cs #####

然后再创建一个脚本：`TestPanel.cs`，用于实现`UI`部分的交互逻辑。

###### 2.3.1、定义变量 ######

先定义一些变量：

private const string IP = "127.0.0.1";
    private const int PORT = 8712;
    
    // 用户名输入
    public InputField unameInput;
    // 消息输入
    public InputField msgInput;
    // 登录按钮
    public Button loginBtn;
    // 发送按钮
    public Button sendBtn;
    // 连接状态文本
    public Text stateTxt;
    // 连接按钮文本
    public Text connectBtnText;
    // 聊天室聊天文本
    public Text chatMsgTxt;
    // 封装的ClientSocket对象
    private ClientSocket clientSocket = new ClientSocket();

###### 2.3.2、登录服务端 ######

// 连接
    clientSocket.Connect(IP, PORT);
    stateTxt.text = clientSocket.connected ? "已连接" : "未连接";
    connectBtnText.text = clientSocket.connected ? "断开" : "连接";
    if (clientSocket.connected)
        unameInput.enabled = false;
    // 登录
    Send("login");

###### 2.3.3、断开连接 ######

clientSocket.CloseSocket();
    stateTxt.text = "已断开";
    connectBtnText.text = "连接";
    unameInput.enabled = true;

###### 2.3.4、发送消息 ######

> 这里用了一个迷你版的`json`库：`JSONConvert`，源码可以参见我之前写的这篇文章[：《用C\#实现一个迷你json库，无需引入dll（可直接放到Unity中使用）》][C_json_dll_Unity]

private void Send(string protocol, string msg = "")
    {
        
        JSONObject jsonObj = new JSONObject();
        jsonObj["protocol"] = protocol;
        jsonObj["uname"] = unameInput.text;
        jsonObj["msg"] = msg;
        // JSONObject转string
        string jsonStr = JSONConvert.SerializeObject(jsonObj);
        // string转byte[]
        byte[] data = System.Text.Encoding.UTF8.GetBytes(jsonStr);
        // 发送消息给服务端
        clientSocket.SendData(data);
    }

###### 2.3.5、接收消息 ######

private void Update()
    {
        
        if (clientSocket.connected)
        {
        
            clientSocket.BeginReceive();
        }
        var msg = clientSocket.GetMsgFromQueue();
    	if (!string.IsNullOrEmpty(msg))
        {
        
        	// 显示到聊天室文本中
            chatMsgTxt.text += msg + "\n";
            Debug.Log("RecvCallBack: " + msg);
        }
    }

###### 2.3.6、完整代码：TestPanel.cs ######

最终，`TestPanel.cs`完整代码如下：

/*
     * 聊天室客户端 UI交互
     * 作者：林新发 博客：https://blog.csdn.net/linxinfa
    */
    
    
    using UnityEngine;
    using UnityEngine.UI;
    
    public class TestPanel : MonoBehaviour
    {
        
        private const string IP = "127.0.0.1";
        private const int PORT = 8712;
    
        // 用户名输入
        public InputField unameInput;
        // 消息输入
        public InputField msgInput;
        // 登录按钮
        public Button loginBtn;
        // 发送按钮
        public Button sendBtn;
        // 连接状态文本
        public Text stateTxt;
        // 连接按钮文本
        public Text connectBtnText;
        // 聊天室聊天文本
        public Text chatMsgTxt;
        // 封装的ClientSocket对象
        private ClientSocket clientSocket = new ClientSocket();
    
        private ClientSocket clientSocket = new ClientSocket();
    
        void Start()
        {
        
            chatMsgTxt.text = "";
    
            loginBtn.onClick.AddListener(() =>
            {
        
                if (clientSocket.connected)
                {
        
                    // 断开
                    clientSocket.CloseSocket();
                    stateTxt.text = "已断开";
                    connectBtnText.text = "连接";
                    unameInput.enabled = true;
                }
                else
                {
        
                    // 连接
                    clientSocket.Connect(IP, PORT);
                    stateTxt.text = clientSocket.connected ? "已连接" : "未连接";
                    connectBtnText.text = clientSocket.connected ? "断开" : "连接";
                    if (clientSocket.connected)
                        unameInput.enabled = false;
                    // 登录
                    Send("login");
                }
            });
    
            sendBtn.onClick.AddListener(() =>
            {
        
                Send("chat", msgInput.text);
            });
        }
    
        private void Update()
        {
        
            if (clientSocket.connected)
            {
        
                clientSocket.BeginReceive();
            }
            var msg = clientSocket.GetMsgFromQueue();
            if (!string.IsNullOrEmpty(msg))
            {
        
                chatMsgTxt.SetAllDirty();
                chatMsgTxt.text += msg + "\n";
                
                Debug.Log("RecvCallBack: " + msg);
            }
        }
    
        private void Send(string protocol, string msg = "")
        {
        
            JSONObject jsonObj = new JSONObject();
            jsonObj["protocol"] = protocol;
            jsonObj["uname"] = unameInput.text;
            jsonObj["msg"] = msg;
            // JSONObject转string
            string jsonStr = JSONConvert.SerializeObject(jsonObj);
            // string转byte[]
            byte[] data = System.Text.Encoding.UTF8.GetBytes(jsonStr);
            // 发送消息给服务端
            clientSocket.SendData(data);
        }
    
        private void OnApplicationQuit()
        {
        
            if (clientSocket.connected)
            {
        
                clientSocket.CloseSocket();
            }
        }
    }

##### 2.4、挂脚本，赋值成员对象 #####

给`TestPanel`界面挂上`TestPanel.cs`脚本，赋值成员对象，如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 6]

#### 3、打包客户端 ####

因为我们要测试多个客户端连接一个服务端，为了方便测试，我们打个`Windows`平台的`exe`。  
在`Build Settings`中添加要打包的场景，选择`PC, Mac & Linux Standalone`平台，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 7]  
我们不想全屏显示客户端，在`Player Settings`中，找到`Resolution and Presentation`，设置`Fullscreen Mode`为`Windowed`，设置窗口默认宽高为`640 x 360`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 8]  
执行打包，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 9]  
打包成功，  
![在这里插入图片描述][20210721094123413.png]

#### 4、运行测试 ####

先使用`python`运行服务端，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 10]  
开启多个客户端，分别登录服务端，用户名分别是`皮皮猫`和`林新发`吧~  
![在这里插入图片描述][20210721094800223.gif]  
服务端的输出：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 11]  
开始聊天，  
![在这里插入图片描述][20210721100144447.gif]  
服务端的输出：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 12]  
运行一切正常，完美。

#### 5、工程源码 ####

上面这个简单聊天室工程源码已上传到`CODE CHINA`，感兴趣的同学可自行下载下来进行学习，  
工程地址：[https://codechina.csdn.net/linxinfa/UnitySocketDemo][https_codechina.csdn.net_linxinfa_UnitySocketDemo]  
注：我使用的`Unity`版本：`Unity 2021.1.9f1c1 (64-bit)`。

> 另外关于`CODE CHINA`的使用教程我之前也写了一篇文章，感兴趣的同学可以看看：  
> [《CODE.CHINA使用教程，创建项目仓库并上传代码（git）》][CODE.CHINA_git]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 13]

### 三、拓展：Mirror Networking ###

#### 1、局域网多人联机Demo的救星：Mirror ####

上面的简单聊天室功能，我们是做了一个独立的服务端负责消息的转发，聊天本身的逻辑非常简单，我们把大部分工作花在了维护`Socket`上，要解决多线程问题，要解决连接断开，要解决消息的序列化和反序列化等等。

有些同学做了一个单机版的小`Demo`，想改成局域网多人联机版，要处理好多复杂的同步问题，比如物理碰撞、状态同步等等，这个对于`Unity`萌新来说，不大友好。  
![在这里插入图片描述][20210721104953925.gif]  
有没有什么好用的网络库可以让开发更高效呢？有，那就是：`Mirror`！

> 注：在`Unity 5.1 ~ Unity2018`中你可以使用`UNet`（全称`Unity Networking`），到`Unity 2019`之后`UNet`就被废弃了，`Mirror`就是来替代`UNet`的。你在网上搜到的`Unity Netwoking`的教程就是`UNet`，它已经过时了，不要再使用`UNet`了！

#### 2、关于Mirror ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 14]  
`Mirror`是`Unity`的高级网络 `API`，支持不同的低级传输（`UDP`、`TCP`、`KCP`等等）。  
使用 `Mirror`，客户端、服务端是在同一个工程中的，这就是为什么它叫`Mirror`。也就是说它没有一个独立的服务端，而是由一台客户端作为`Host`，它既是客户端又是服务端，其他客户端连接这台`Host`客户端。画成图是这样子：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 15]  
`Mirror`是开源的，它的社区很活跃，配套的文档也很详尽，大家可以从官网进行学习，不过是全英文的。

**Mirror官网：**  
[https://mirror-networking.com/][https_mirror-networking.com]

**Mirror GitHub:**  
[https://github.com/vis2k/Mirror][https_github.com_vis2k_Mirror]

**Mirror Asset Store:**  
[https://assetstore.unity.com/packages/tools/network/mirror-129321][https_assetstore.unity.com_packages_tools_network_mirror-129321]

**Mirror 官方文档：**  
[https://mirror-networking.gitbook.io/docs/][https_mirror-networking.gitbook.io_docs]

**Mirror API手册：**  
[https://mirror-networking.com/docs/api/Mirror.html][https_mirror-networking.com_docs_api_Mirror.html]

**Unity 与 Mirror的兼容：**  
`Mirror`最适合`Unity 2019 LTS`。  
`Mirror`通常也适用于所有较新的`LTS`版本（即`2020 LTS`）。

#### 3、Mirror插件下载 ####

建议从`Asset Store`上下载`Mirror`版本，因为`GitHub`的版本不一定稳定，  
`Asset Store`地址:  
[https://assetstore.unity.com/packages/tools/network/mirror-129321][https_assetstore.unity.com_packages_tools_network_mirror-129321]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 16]  
将`Mirror`插件添加到自己的账号中，然后回到`Unity`，在`Package Manager`中就可以下载了，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 17]  
下载下来导入`Unity`中，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 18]

#### 4、Mirror 案例测试：多人坦克对战 ####

`Mirror`中给我们提供了几个例子，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 19]  
我以多人坦克对战为例，双击`Assets / Mirror / Examples / Tanks / Scenes/ Scene`进入场景，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 20]  
运行后左上角出现三个按钮，如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 21]  
要开启两个客户端，为了方便演示，我先打出个`exe`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 22]  
打包成功后，运行两个客户端，其中一个作为`Host`，另一个客户端连接`Host`，运行效果如下：  
![在这里插入图片描述][20210721150703415.gif]  
可以看到我们对坦克的控制是实时同步到另一个端的。

#### 5、Mirror 案例讲解：多人坦克对战 ####

下面，我以多人坦克对战案例为例，给大家讲下制作过程。  
为了让大家有个直观理解，我画个图：  
![请添加图片描述][689eacf31abc900f3a69001730fff7c3.png]

##### 5.1、NetworkManager物体 #####

先创建一个空物体，重命名为`NetworkManager`，挂以下三个脚本：  
`NetworkManager`、`NetworkManagerHUD`、`KcpTransport`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 23]

###### 5.1.1、NetworkManager组件 ######

我们先看下官方手册：[https://mirror-networking.gitbook.io/docs/components/network-manager][https_mirror-networking.gitbook.io_docs_components_network-manager]  
![在这里插入图片描述][348e34d929fad64c98cfafa619edfce6.png]  
意思就是，`NetworkManager`是管理多个客户端连接的组件。它是多人联机游戏的核心控制组件。  
一个场景中只能有一个激活的`NetworkManager`（它是单例模式的）。  
连接的服务端`IP`地址在`NetworkManager`中进行设置，`Max Connections`是最大连接数。  
（注意：任何一个客户端都可以同时是一个服务端）  
![在这里插入图片描述][93a0fe4665f72caee20d7b86c74f21ab.png]

###### 5.1.2、NetworkManagerHUD组件 ######

`NetworkManagerHUD`组件是下面这个`GUI`的逻辑，通过它我们可以方便地进行测试。  
![在这里插入图片描述][6cbfc41f3f5c89b26aa3b1b14041fe82.png]

###### 5.1.3、KcpTransport组件 ######

`Mirror`帮我们封装了各种不同等级的传输协议（各种`Transport`组件），常用的是`KcpTransport`和`TelepathyTransport`。  
`KcpTransport`是使用可靠`UDP`协议，`TelepathyTransport`是使用`TCP`协议。  
![在这里插入图片描述][46ba87b6b569065b168b317061d1269d.png]

`Transport`组件中可以设置端口号、最大延迟等等参数：  
![在这里插入图片描述][c59ce55ca54952e5a8881e5c4a73c4dc.png]

##### 5.2、地面（带导航功能） #####

###### 5.2.1、创建Plane ######

创建一个`Plane`作为地面地面，重命名为`Ground`，给它赋值一个材质球，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 24]  
效果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 25]

###### 5.2.2、导航烘焙：Navigation ######

接下来我们对地面执行导航系统烘焙，这样方便限制坦克的活动范围。  
我们将地面设置为静态对象，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 26]  
点击菜单`Window / AI / Navigation`，打开`Navigation`（导航/寻路系统）视图，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 27]  
在`Navigation`视图中点击`Bake`标签按钮，点击`Bake`按钮，对地面进行导航烘焙，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 28]  
看到蓝色网格则说明烘焙成功，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 29]

##### 5.3、坦克生成点：NewworkStartPosition #####

创建四个空物体，重名命为`Spawn`，挂上`NewworkStartPosition`，

> 注：如果不创建生成点，则坦克默认在`(0, 0, 0)`坐标点出生成。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 30]  
调节四个生成点的位置，分散在地面的四个角落，如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 31]

##### 5.4、坦克身上的组件 #####

###### 5.4.1、坦克预设 ######

准备一个坦克模型，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 32]  
包装成坦克预设：`Tank.prefab`，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 33]  
坦克预设上挂以下脚本：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 34]

###### 5.4.2、NavMeshAgent组件 ######

`NavMeshAgent`组件是导航代理组件，挂上这个组件就具备了导航功能；  
关于导航系统的使用，可以参见我之前写的文章：[《Unity游戏开发——新发教你做游戏（五）：导航系统Navigation》][Unity_Navigation]  
![20200930154637832.gif][]  
[《\[原创\] 用Unity等比例制作广州地铁，广州加油，早日战胜疫情（Unity | 地铁地图 | 第三人称视角）》][_Unity_Unity _ _ _]  
![20210603231452659.gif][]

###### 5.4.4、Animator组件 ######

动画控制器，用于控制坦克的行驶、开炮等动画。  
![在这里插入图片描述][e8f18ec55cc1ce07bd62433836934e1a.png]  
关于`Animator`相关的教程，我之前写过两篇文章：[《Unity动画状态机Animator使用》][Unity_Animator]、  
[《Animator控制角色动画播放》][Animator]，感兴趣的同学可以看看。

###### 5.4.5、NetworkTransform组件 ######

我们先看下官方手册：[https://mirror-networking.gitbook.io/docs/components/network-transform][https_mirror-networking.gitbook.io_docs_components_network-transform]  
![在这里插入图片描述][6035542d2e4a5fc42bfe6181e10e383c.png]  
意思就是说，`NetworkTransform`组件会通过网络自动同步`position`、`rotation`和`scale`。  
带`NetworkTransform`组件的物体必须也带`NetworkIdentity`组件。  
![在这里插入图片描述][7f7a61d6430ea0d5c591edf66de0c662.png]  
我们可以设置`Positon`、`Rotation`、`Scale`同步的敏感度，  
![在这里插入图片描述][0d0bfd234b92faff67888788d8ac8ef8.png]  
为了让同步有一个平滑效果（不会一卡一卡的），我们可以勾选平滑差值，  
![在这里插入图片描述][9615f5acee3032d91dc72ddad5d9d0d0.png]

###### 5.4.6、NetworkIdentity组件 ######

我们先看下官方手册：[https://mirror-networking.gitbook.io/docs/components/network-identity][https_mirror-networking.gitbook.io_docs_components_network-identity]  
![在这里插入图片描述][61d30e1e36c4864a2c195aaa8ac12b67.png]  
意思就是说，`NetworkIdentity`组件提供了游戏物体在网络中的唯一标识（`ID`）。  
游戏运行过程中，我们在`Inspector`视图中预览到`NetworkIdentity`的信息。  
![在这里插入图片描述][a920e67fcb409b52d4a0cb222698a56f.png]

###### 5.4.7、NetworkBehaviour组件: Tank ######

`Tank`脚本是坦克行为脚本，它继承`NetworkBehaviour`。  
这里只讲`NetworkBehaviour`组件，`Tank`具体代码后面再讲~  
我们先看看官方手册：[https://mirror-networking.gitbook.io/docs/guides/networkbehaviour][https_mirror-networking.gitbook.io_docs_guides_networkbehaviour]  
![在这里插入图片描述][312de151039420e6ff67b4e96fe08c8f.png]  
意思就是说，`NetworkBehaviour`脚本处理具有`NetworkIdentity`组件的游戏对象，`NetworkBehaviour`的子类中可以处理高级`API`功能，例如`Commands`、`ClientRpc's`、`SyncEvents`、`SyncVars`。

> **NetworkBehaviour组件具有以下功能：**  
> `Synchronized variables`：同步变量  
> `Network callbacks`：网络回调  
> `Server and client functions`：服务端和客户端函数  
> `Sending commands`：发送命令  
> `Client RPC calls`：客户端远程过程调用  
> `Networked events`：网络事件  
> ![在这里插入图片描述][a370288aaf3ac5fe13b6cff0da203718.png]

> `NetworkBehaviour`提供了一些 **网络回调**：  
> **OnStartServer回调**  
> 这个回调函数只在服务端调用，当在服务端生成一个游戏对象，或者服务端启动时被回调。  
> **OnStopServer回调**  
> 这个回调函数只在服务端调用，当在服务端销毁一个游戏对象，或者服务端停止时被回调。  
> **OnStartClient回调**  
> 这个回调函数只在客户端调用，当客户端生成一个游戏对象，或者客户端连接到服务端时被回调。  
> **OnStopClient回调**  
> 这个回调函数只在客户端调用，当服务端销毁一个游戏对象时被回调。  
> **OnStartLocalPlayer回调**  
> 这个回调函数只在客户端调用，当客户端生成一个玩家对象时被回调。  
> **OnStartAuthority回调**  
> 这个回调函数只在客户端调用，当游戏对象拿到控制权时。  
> **OnStopAuthority回调**  
> 这个回调函数只在客户端调用，当游戏对象失去控制权时。

> **标记服务端函数或客户端函数：**  
> 在`NetworkBehaviour`中，我们可以使用`[Server]`、`[ServerCallback]`、`[Client]`、`[ClientCallback]`这些注解对函数进行标注。  
> `[Server]`、`[ServerCallback]`表示函数为服务端函数，只在服务端执行；  
> `[Client]`、`[ClientCallback]`表示为客户端函数，只在客户端执行。

> **Command 命令：**  
> 使用`[Command]`注解对函数进行标记，表示这个函数是由客户端调用，由服务端来执行。具体原理我下文会通过反编译`dll`来解释。  
> 被`[Command]`标记的函数约定以`Cmd`开头。

> **Client RPC 客户端远程过程调用：**  
> 使用`[ClientRpc]`注解对函数进行标记，表示这个函数是由服务端调用，由客户端来执行。具体原理我下文会通过反编译`dll`来解释。  
> 被`[ClientRpc]`标记的函数约定以`Rpc`开头。

> **Networked Events 网络事件（观察者模式）：**  
> 类似于`Client RPC`调用，不同之处是它触发的是事件。  
> 使用`[SyncEvent]`对事件进行标记。被`[SyncEvent]`标记的事件变量必须以`Event`开头，例`EventTakeDamage`。例子可以参见官方手册：[https://mirror-networking.gitbook.io/docs/guides/synchronization/syncevent][https_mirror-networking.gitbook.io_docs_guides_synchronization_syncevent]

`Mirror`提供的函数注解如下（部分注解我们上面已做了介绍），具体的注解可以参见`Mirror`官方手册：[https://mirror-networking.gitbook.io/docs/guides/attributes][https_mirror-networking.gitbook.io_docs_guides_attributes]  
![在这里插入图片描述][003d182192c6c18b5b19e07eb8e87f92.png]

##### 5.5、赋值PlayerPrefab #####

选中`NetworkManager`物体，给`NetworkManager`组件赋值`PlayerPrefab`为坦克预设，  
![在这里插入图片描述][3bd637394997970cb28380189577552f.png]

##### 5.6、炮弹预设 #####

准备一个炮弹模型，  
![在这里插入图片描述][352b690e943097436e2bd3e881a536ca.png]  
包装成炮弹预设：`Projectile.prefab`，  
![在这里插入图片描述][2039e521b75b9484f66e791c10acfe76.png]  
炮弹预设上挂以下脚本：  
![在这里插入图片描述][47eee873955eb5f7c504596f1448db97.png]  
`NetworkIdentity`：因为炮弹也是一个网络对象，所以它需要`NetworkIdentity`组件；  
炮弹的`Transform`信息不使用`NetworkTransform`进行同步，而是通过`Rigibody`刚体组件的力来使炮弹飞行，所以只需要同步一下力即可，在`Projectile`脚本中实现炮弹的逻辑。

##### 5.7、坦克脚本：Tank.cs #####

网络对象的行为脚本需要继承`NetworkBehaviour`，所以`Tank`类需要继承`NetworkBehaviour`，

public class Tank : NetworkBehaviour
    {
        
    }

`Tank`脚本要实现的逻辑是坦克的 **移动 / 旋转** 、**开炮**。  
其中移动的同步会自动通过`NetworkTransform`进行同步，所以我们只需对本地坦克进行控制即可，

// Tank.cs
    
    void Update()
    {
        
        // isLocalPlayer是父类NetworkBehaviour的属性，用于判断当前NetworkBehaviour对象是否为本地对象；
        if (!isLocalPlayer) return;
    
        // 旋转
        float horizontal = Input.GetAxis("Horizontal");
        transform.Rotate(0, horizontal * rotationSpeed * Time.deltaTime, 0);
    
        // 移动
        float vertical = Input.GetAxis("Vertical");
        Vector3 forward = transform.TransformDirection(Vector3.forward);
        agent.velocity = forward * Mathf.Max(vertical, 0) * agent.speed;
        animator.SetBool("Moving", agent.velocity != Vector3.zero);
    	
    	// ...
    }

开炮需要由服务端来执行，

// Tank.cs
    
    void Update()
    {
        
    	// ...
    	
    	if (Input.GetKeyDown(shootKey))
        {
        
            CmdFire();
        }
    }
    
    // this is called on the server
    [Command]
    void CmdFire()
    {
        
        GameObject projectile = Instantiate(projectilePrefab, projectileMount.position, transform.rotation);
        NetworkServer.Spawn(projectile);
        RpcOnFire();
    }
    
    // this is called on the tank that fired for all observers
    [ClientRpc]
    void RpcOnFire()
    {
        
        animator.SetTrigger("Shoot");
    }

这里用到了两个注解`[Command]`、`[ClientRpc]`，我们上面讲到它是`NetworkBehaviour`组件的函数注解。  
上面我们讲到`[Command]`，它是由客户端来调用，由服务端来执行。  
这个怎么理解呢？  
事实上`Mirror`实现了一些编译器`hack`，会在编译阶段动态生成特定的代码（也就是把你的代码编译为别的代码）。  
这样讲好像不好理解，没事，我们反编译一下`C#`的`dll`就知道了。  
进入`工程路径 / Library / ScriptAssemblies`这个目录，`Mirror`的案例代码是编译在`Mirror.Examples.dll`中，  
![在这里插入图片描述][698f21c7a62425335bf6286bd51820ef.png]  
我们使用`ILSpy.exe`对它进行反编译，

> 注：`ILSpy`反编译工具可以从`GitHub`下载：[https://github.com/icsharpcode/ILSpy][https_github.com_icsharpcode_ILSpy]

我们看到反编译出来的`Tank`的`CmdFire`函数的代码已经完全变了另外一个逻辑了，它发送了一个`“CmdFire”`消息给服务端，  
![在这里插入图片描述][334acc3925b6be336e80ba3d7b90d8f5.png]  
开炮流程变成了下面这样子：  
![在这里插入图片描述][a613dcd3e44363cdae099624854d800e.png]  
同理，`[ClientRpc]`是由服务端调用，由客户端执行。  
我们的代码：  
![在这里插入图片描述][e1c24fabf8a5dc79dbd7655b419ef7cd.png]  
编译后：  
![在这里插入图片描述][2878aeade0e5d98349c4940ab2909c60.png]  
![在这里插入图片描述][18e9de59189ffb1f3d3b203c9e195f06.png]  
完整的`Tank.cs`代码入下：

using UnityEngine;
    using UnityEngine.AI;
    
    namespace Mirror.Examples.Tanks
    {
        
        public class Tank : NetworkBehaviour
        {
        
            [Header("Components")]
            public NavMeshAgent agent;
            public Animator animator;
    
            [Header("Movement")]
            public float rotationSpeed = 100;
    
            [Header("Firing")]
            public KeyCode shootKey = KeyCode.Space;
            public GameObject projectilePrefab;
            public Transform projectileMount;
    
            void Update()
            {
        
                // movement for local player
                if (!isLocalPlayer) return;
    
                // rotate
                float horizontal = Input.GetAxis("Horizontal");
                transform.Rotate(0, horizontal * rotationSpeed * Time.deltaTime, 0);
    
                // move
                float vertical = Input.GetAxis("Vertical");
                Vector3 forward = transform.TransformDirection(Vector3.forward);
                agent.velocity = forward * Mathf.Max(vertical, 0) * agent.speed;
                animator.SetBool("Moving", agent.velocity != Vector3.zero);
    
                // shoot
                if (Input.GetKeyDown(shootKey))
                {
        
                    CmdFire();
                }
            }
    
            // this is called on the server
            [Command]
            void CmdFire()
            {
        
                GameObject projectile = Instantiate(projectilePrefab, projectileMount.position, transform.rotation);
                NetworkServer.Spawn(projectile);
                RpcOnFire();
            }
    
            // this is called on the tank that fired for all observers
            [ClientRpc]
            void RpcOnFire()
            {
        
                animator.SetTrigger("Shoot");
            }
        }
    }

##### 5.8、Transform的网络同步：NetworkTransform.cs #####

坦克身上挂`NetworkTransform`组件，坦克`Transform`的同步由它来负责。

##### 5.9、炮弹脚本：Projectile.cs #####

炮弹也是一个网络对象，它的行为脚本也必须继承`NetworkBehaviour`，

// Projectile.cs
    public class Projectile : NetworkBehaviour
    {
        
    }

炮弹预设实例化后，需要给`Rigibody`一个力，从而让炮弹向前飞行，

// Projectile.cs
    void Start()
    {
        
       	rigidBody.AddForce(transform.forward * force);
    }

炮弹需要有一个生命周期控制，超过`5秒`自动销毁，执行`NetworkServer.Destroy(gameObject)`来销毁对象，

// Projectile.cs
    public override void OnStartServer()
    {
        
        Invoke(nameof(DestroySelf), destroyAfter);
    }
    
    [Server]
    void DestroySelf()
    {
        
        NetworkServer.Destroy(gameObject);
    }

我们看到这里有一个`[Server]`注解，它表示只有服务端可以调用此函数。

我们反编译可以看到它自动加了一个`NetworkServer.active`判断，  
![在这里插入图片描述][3afdcbec3eeb89a8e10442bebd35a39f.png]  
我们再看`[ServerCallback]`，它与`[Server]`一样，只能在服务端调用，只是没有`Warning`输出而已，如下  
![在这里插入图片描述][5ba81076d9e85791ab5c3e46424e38a4.png]  
编译后：  
![在这里插入图片描述][723525ef0fc7a8fe415e24403ba15f73.png]  
完整的`Projectile.cs`代码如下：

using UnityEngine;
    
    namespace Mirror.Examples.Tanks
    {
        
        public class Projectile : NetworkBehaviour
        {
        
            public float destroyAfter = 5;
            public Rigidbody rigidBody;
            public float force = 1000;
    
            public override void OnStartServer()
            {
        
                Invoke(nameof(DestroySelf), destroyAfter);
            }
    
            // set velocity for server and client. this way we don't have to sync the
            // position, because both the server and the client simulate it.
            void Start()
            {
        
                rigidBody.AddForce(transform.forward * force);
            }
    
            // destroy for everyone on the server
            [Server]
            void DestroySelf()
            {
        
                NetworkServer.Destroy(gameObject);
            }
    
            // ServerCallback because we don't want a warning if OnTriggerEnter is
            // called on the client
            [ServerCallback]
            void OnTriggerEnter(Collider co)
            {
        
                NetworkServer.Destroy(gameObject);
            }
        }
    }

### 四、完毕 ###

好了，就先写这么多吧~

最后再补充一个，我之前写了一篇关于`UnityWebRequest`的文章，它也与网络通信相关，大家感兴趣的也可以看下：[《长江后浪推前浪，UnityWebRequest替代WWW》][UnityWebRequest_WWW]

我是新发，喜欢我的可以点赞、关注、收藏，如果有什么技术上的疑问，欢迎留言或私信，拜拜~

[20210720100330896.png]: /images/20220829/8f8ea3a231054e10af39d35b21ede7af.png
[Unity_Mesh _ _ _ _ _ _]: https://linxinfa.blog.csdn.net/article/details/118669910
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70]: /images/20220829/ec5abbfeb1b241548b3e3b2ca6e369ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 1]: /images/20220829/d6b740f7a4484e0d81bd1f710bcdf124.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 2]: /images/20220829/86c2d9709f4d4c6da9207b3eabf53fad.png
[20210720103158175.png]: /images/20220829/63f8913c575148e28fbdebad1af2d88d.png
[20210721085329951.png]: /images/20220829/cf07d76732fa48beb1635c9b5cae743d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 3]: /images/20220829/67c709ca3d504463a40b7474f73d5c8f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 4]: /images/20220829/d2c375bd3be94e9ebbf56bc60350252a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 5]: /images/20220829/f4a4687efde745c490df8e37b9079f7a.png
[C_json_dll_Unity]: https://linxinfa.blog.csdn.net/article/details/109095957
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 6]: /images/20220829/ddaaaa4f4a2d4b3693bf0b6625b259a7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 7]: /images/20220829/71383bea994f4177a4e4c8ecb2df5902.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 8]: /images/20220829/27fdeb1288984436a3ab945f35c3274d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 9]: /images/20220829/ca0028900f1c49fda2c8dafaea158a91.png
[20210721094123413.png]: /images/20220829/04de3867eb774443bf5efdcace060b6c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 10]: /images/20220829/242707d4d3f2439bb525aafe5797c7db.png
[20210721094800223.gif]: /images/20220829/30e01e5ed84841b6a2165f7830c9a7a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 11]: /images/20220829/f81522df17e94956be60a6afbb2d0597.png
[20210721100144447.gif]: /images/20220829/c7c2397840f24b6e89b37f526acfaa02.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 12]: /images/20220829/f1ba419b36624d8a948bca02651ea5cd.png
[https_codechina.csdn.net_linxinfa_UnitySocketDemo]: https://codechina.csdn.net/linxinfa/UnitySocketDemo
[CODE.CHINA_git]: https://blog.csdn.net/linxinfa/article/details/108730290
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 13]: /images/20220829/72092e8339654deaa8122f09cf4b83ad.png
[20210721104953925.gif]: /images/20220829/825146d7660f450c8ab069dba4509a42.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 14]: /images/20220829/165526acce934b96861bee57435e57c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 15]: /images/20220829/46307febd9544b5d81d2d9d848612ebd.png
[https_mirror-networking.com]: https://mirror-networking.com/
[https_github.com_vis2k_Mirror]: https://github.com/vis2k/Mirror
[https_assetstore.unity.com_packages_tools_network_mirror-129321]: https://assetstore.unity.com/packages/tools/network/mirror-129321
[https_mirror-networking.gitbook.io_docs]: https://mirror-networking.gitbook.io/docs/
[https_mirror-networking.com_docs_api_Mirror.html]: https://mirror-networking.com/docs/api/Mirror.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 16]: /images/20220829/5eba0af18946444bad1d259ee693f390.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 17]: /images/20220829/628f90913b434036b3bcd5814cf7ef6a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 18]: /images/20220829/db2c8e6141604d488250e186b634599b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 19]: /images/20220829/8d98169bf86244e88e251edd1567db45.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 20]: /images/20220829/dbcd45e77210406c8dbbe06694eee27c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 21]: /images/20220829/388681850ad448efb5e931c0eca37286.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 22]: /images/20220829/eda52a41beea4cb6a2cb16b22ebaa1aa.png
[20210721150703415.gif]: /images/20220829/1a6bcab291954d8e9968f3d7e3cbdc4a.png
[689eacf31abc900f3a69001730fff7c3.png]: /images/20220829/4622e7eae6624b86aaca868508435d6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 23]: /images/20220829/0ab84875f3b34907a005493696c37387.png
[https_mirror-networking.gitbook.io_docs_components_network-manager]: https://mirror-networking.gitbook.io/docs/components/network-manager
[348e34d929fad64c98cfafa619edfce6.png]: /images/20220829/d499dfe2c5874829bc31e014c1f2455f.png
[93a0fe4665f72caee20d7b86c74f21ab.png]: /images/20220829/6a87d5ee717147a0b55b25c61ff90cb9.png
[6cbfc41f3f5c89b26aa3b1b14041fe82.png]: /images/20220829/0b8f75d891d64442a02ef9012187ec8c.png
[46ba87b6b569065b168b317061d1269d.png]: /images/20220829/9a2b53e851d2425fb549d43abb233c49.png
[c59ce55ca54952e5a8881e5c4a73c4dc.png]: /images/20220829/167e16890c334fe3a26b6bfbcb907460.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 24]: /images/20220829/9f1444e6b42f465ebb34b41ab0cd0619.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 25]: /images/20220829/2a335e9d817848dcabae15e17bd89db4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 26]: /images/20220829/ee1b548acca54740aabc660505fa60e5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 27]: /images/20220829/2eee2d61e1fc44c1b2151da7b124d0d3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 28]: /images/20220829/2bfe0603be4249f2b026ce5d646e0d0c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 29]: /images/20220829/8bee7d7bef6a4545a18f2820b4699db1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 30]: /images/20220829/0f1b9dace9a84ba088fbdd5ed431cc5f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 31]: /images/20220829/93c398968d384ab8a3259547f9c0176a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 32]: /images/20220829/9d340d02da8d45bb831f1859739d9db2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 33]: /images/20220829/788e037709cc459598d074d698aabac7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnhpbmZh_size_16_color_FFFFFF_t_70 34]: /images/20220829/53df229446d44440b3548c2361a4c2e7.png
[Unity_Navigation]: https://blog.csdn.net/linxinfa/article/details/108909396
[20200930154637832.gif]: /images/20220829/5970ee41054342e0a929fcec4c2701af.png
[_Unity_Unity _ _ _]: https://blog.csdn.net/linxinfa/article/details/117536057
[20210603231452659.gif]: /images/20220829/0865b2dadd544c40a8f7b7c915e84f60.png
[e8f18ec55cc1ce07bd62433836934e1a.png]: /images/20220829/7b27771d0f69444c96b9319595b44708.png
[Unity_Animator]: https://blog.csdn.net/linxinfa/article/details/94392971
[Animator]: https://blog.csdn.net/linxinfa/article/details/108960363
[https_mirror-networking.gitbook.io_docs_components_network-transform]: https://mirror-networking.gitbook.io/docs/components/network-transform
[6035542d2e4a5fc42bfe6181e10e383c.png]: /images/20220829/8348219038a444bc870da9f51e23b25d.png
[7f7a61d6430ea0d5c591edf66de0c662.png]: /images/20220829/b48927084eb744be9bac802e2c2e99c1.png
[0d0bfd234b92faff67888788d8ac8ef8.png]: /images/20220829/94d13f5746bd43359c28b0d48912293a.png
[9615f5acee3032d91dc72ddad5d9d0d0.png]: /images/20220829/dba3f504ca4540f7ba21666d51977c4c.png
[https_mirror-networking.gitbook.io_docs_components_network-identity]: https://mirror-networking.gitbook.io/docs/components/network-identity
[61d30e1e36c4864a2c195aaa8ac12b67.png]: /images/20220829/0d1d75e9bf2f4dc28d872972dd21832c.png
[a920e67fcb409b52d4a0cb222698a56f.png]: /images/20220829/17d1a307de9247d180dd4bcc88cbc85f.png
[https_mirror-networking.gitbook.io_docs_guides_networkbehaviour]: https://mirror-networking.gitbook.io/docs/guides/networkbehaviour
[312de151039420e6ff67b4e96fe08c8f.png]: /images/20220829/7e851d2cf5ab44d8a7dfa9480ea5bcc9.png
[a370288aaf3ac5fe13b6cff0da203718.png]: /images/20220829/af14a5c9767e4c13b9988d9814fe822b.png
[https_mirror-networking.gitbook.io_docs_guides_synchronization_syncevent]: https://mirror-networking.gitbook.io/docs/guides/synchronization/syncevent
[https_mirror-networking.gitbook.io_docs_guides_attributes]: https://mirror-networking.gitbook.io/docs/guides/attributes
[003d182192c6c18b5b19e07eb8e87f92.png]: /images/20220829/140ab59ac08244ee909f6482154af53b.png
[3bd637394997970cb28380189577552f.png]: /images/20220829/dc72f2ac460947c89e1dfff98fdd486d.png
[352b690e943097436e2bd3e881a536ca.png]: /images/20220829/5e49ccde2aba40748b0fb7137cd8e5e5.png
[2039e521b75b9484f66e791c10acfe76.png]: /images/20220829/5ba36155ac424dd88dfbfd21c1a7f969.png
[47eee873955eb5f7c504596f1448db97.png]: /images/20220829/e47a4c6f4774414881cf36c67f6e3650.png
[698f21c7a62425335bf6286bd51820ef.png]: /images/20220829/95f7a9ab49c04d049bf43501a9d7ebfb.png
[https_github.com_icsharpcode_ILSpy]: https://github.com/icsharpcode/ILSpy
[334acc3925b6be336e80ba3d7b90d8f5.png]: /images/20220829/d5b3c5bba26f46888c68a8179eb859f9.png
[a613dcd3e44363cdae099624854d800e.png]: /images/20220829/e6fc8812ce7b48e8a8f0e81928a6f61a.png
[e1c24fabf8a5dc79dbd7655b419ef7cd.png]: /images/20220829/d04712284141406792b76eedeec1028c.png
[2878aeade0e5d98349c4940ab2909c60.png]: /images/20220829/c5255e45050249d3ade420e242e61218.png
[18e9de59189ffb1f3d3b203c9e195f06.png]: /images/20220829/7e54e8b3c57c436e98bc26fd49182ceb.png
[3afdcbec3eeb89a8e10442bebd35a39f.png]: /images/20220829/119b65c96baa46369f8b9e05293117e6.png
[5ba81076d9e85791ab5c3e46424e38a4.png]: /images/20220829/273650e6d4e84819b44031c3a6befbce.png
[723525ef0fc7a8fe415e24403ba15f73.png]: /images/20220829/92c6147be464405799d5b53cf194ff40.png
[UnityWebRequest_WWW]: https://blog.csdn.net/linxinfa/article/details/94436027