• Unity源码3||秀翻同学和老师

    1，Unity C# 答题系统源码——可随机出题

    1. using System.Collections.Generic;
    2.  
    3. using UnityEngine;
    4.  
    5. using UnityEngine.UI;
    6.  
    7.  
    8.  
    9. public class Answer : MonoBehaviour
    10.  
    11. {
    12.  
    13.     //读取文档
    14.  
    15.     string[][] ArrayX;//题目数据
    16.  
    17.     string[] lineArray;//读取到题目数据
    18.  
    19.     private int topicMax = 0;//最大题数
    20.  
    21.     private List<bool> isAnserList = new List<bool>();//存放是否答过题的状态
    22.  
    23.  
    24.  
    25.     //加载题目
    26.  
    27.     public GameObject tipsbtn;//提示按钮
    28.  
    29.     public Text tipsText;//提示信息
    30.  
    31.     public List toggleList;//答题Toggle
    32.  
    33.     public Text indexText;//当前第几题
    34.  
    35.     public Text TM_Text;//当前题目
    36.  
    37.     public List DA_TextList;//选项
    38.  
    39.     private int topicIndex = 0;//第几题
    40.  
    41.  
    42.  
    43.     //按钮功能及提示信息
    44.  
    45.     public Button BtnBack;//上一题
    46.  
    47.     public Button BtnNext;//下一题
    48.  
    49.     public Button BtnTip;//消息提醒
    50.  
    51.     public Text TextAccuracy;//正确率
    52.  
    53.     private int anserint = 0;//已经答过几题
    54.  
    55.     private int isRightNum = 0;//正确题数
    56.  
    57.  
    58.  
    59.     private List<int> randomNum = new List<int>();  //存放随机数
    60.  
    61.  
    62.  
    63.     void Awake()
    64.  
    65.     {
    66.  
    67.         TextCsv();
    68.  
    69.         LoadAnswer();
    70.  
    71.     }
    72.  
    73.     void Start()
    74.  
    75.     {
    76.  
    77.         toggleList[0].onValueChanged.AddListener((isOn) => AnswerRightRrongJudgment(isOn,0));
    78.  
    79.         toggleList[1].onValueChanged.AddListener((isOn) => AnswerRightRrongJudgment(isOn,1));
    80.  
    81.         toggleList[2].onValueChanged.AddListener((isOn) => AnswerRightRrongJudgment(isOn,2));
    82.  
    83.         toggleList[3].onValueChanged.AddListener((isOn) => AnswerRightRrongJudgment(isOn,3));
    84.  
    85.  
    86.  
    87.         BtnTip.onClick.AddListener(() => Select_Answer(0));
    88.  
    89.         BtnBack.onClick.AddListener(() => Select_Answer(1));
    90.  
    91.         BtnNext.onClick.AddListener(() => Select_Answer(2));
    92.  
    93.     }
    94.  
    95.     /*****************读取txt数据******************/
    96.  
    97.     void TextCsv()
    98.  
    99.     {
    100.  
    101.         //读取csv二进制文件  
    102.  
    103.         TextAsset binAsset = Resources.Load("YW", typeof(TextAsset)) as TextAsset;
    104.  
    105.         //读取每一行的内容  
    106.  
    107.         lineArray = binAsset.text.Split('\r');
    108.  
    109.         //创建二维数组  
    110.  
    111.         ArrayX = new string[lineArray.Length][];
    112.  
    113.         //把csv中的数据储存在二维数组中  
    114.  
    115.         for (int i = 0; i < lineArray.Length; i++)
    116.  
    117.         {
    118.  
    119.             ArrayX[i] = lineArray[i].Split(':');
    120.  
    121.         }
    122.  
    123.         //设置题目状态
    124.  
    125.         topicMax = lineArray.Length;
    126.  
    127.         for (int x = 0; x < topicMax + 1; x++)
    128.  
    129.         {
    130.  
    131.             isAnserList.Add(false);
    132.  
    133.         }
    134.  
    135.     }
    136.  
    137.     /*****************加载题目******************/
    138.  
    139.     void LoadAnswer()
    140.  
    141.     {
    142.  
    143.         for (int i = 0; i < toggleList.Count; i++)
    144.  
    145.         {
    146.  
    147.             toggleList[i].isOn = false;
    148.  
    149.         }
    150.  
    151.         for (int i = 0; i < toggleList.Count; i++)
    152.  
    153.         {
    154.  
    155.             toggleList[i].interactable = true;
    156.  
    157.         }
    158.  
    159.         GetRandomNum();  //获得随机数
    160.  
    161.         tipsbtn.SetActive(false);
    162.  
    163.         tipsText.text = "";
    164.  
    165.         indexText.text = "第" + (topicIndex + 1) + "题：";//第几题
    166.  
    167.         TM_Text.text = ArrayX[randomNum[topicIndex]][1];//题目
    168.  
    169.         int idx = ArrayX[topicIndex].Length - 3;//有几个选项
    170.  
    171.         for (int x = 0; x < idx; x++)
    172.  
    173.         {
    174.  
    175.             DA_TextList[x].text = ArrayX[randomNum[topicIndex]][x + 2];//选项
    176.  
    177.         }
    178.  
    179.     }
    180.  
    181.     /*****************按钮功能******************/
    182.  
    183.     void Select_Answer(int index)
    184.  
    185.     {
    186.  
    187.         switch (index)
    188.  
    189.         {
    190.  
    191.             case 0://提示
    192.  
    193.                 int idx = ArrayX[randomNum[topicIndex]].Length - 1;
    194.  
    195.                 int n = int.Parse(ArrayX[randomNum[topicIndex]][idx]);
    196.  
    197.                 string nM = "";
    198.  
    199.                 switch (n)
    200.  
    201.                 {
    202.  
    203.                     case 1:
    204.  
    205.                         nM = "A";
    206.  
    207.                         break;
    208.  
    209.                     case 2:
    210.  
    211.                         nM = "B";
    212.  
    213.                         break;
    214.  
    215.                     case 3:
    216.  
    217.                         nM = "C";
    218.  
    219.                         break;
    220.  
    221.                     case 4:
    222.  
    223.                         nM = "D";
    224.  
    225.                         break;
    226.  
    227.                 }
    228.  
    229.                 tipsText.text = "" +"正确答案是："+ nM + "";
    230.  
    231.                 break;
    232.  
    233.             case 1://上一题
    234.  
    235.                 if (topicIndex > 0) 
    236.  
    237.                 {
    238.  
    239.                     topicIndex--;
    240.  
    241.                     LoadAnswer();
    242.  
    243.                 }
    244.  
    245.                 else
    246.  
    247.                 {
    248.  
    249.                     tipsText.text = "" + "前面已经没有题目了！" + "";
    250.  
    251.                 }
    252.  
    253.                 break;
    254.  
    255.             case 2://下一题
    256.  
    257.                 if (topicIndex < topicMax - 1) 
    258.  
    259.                 {
    260.  
    261.                     topicIndex++;
    262.  
    263.                     LoadAnswer();
    264.  
    265.                 }
    266.  
    267.                 else
    268.  
    269.                 {
    270.  
    271.                     tipsText.text = "" + "哎呀！已经是最后一题了。" + "";
    272.  
    273.                 }
    274.  
    275.                 break;
    276.  
    277.         }
    278.  
    279.     }
    280.  
    281.  
    282.  
    283.     /*****************题目对错判断******************/
    284.  
    285.     void AnswerRightRrongJudgment(bool check,int index)
    286.  
    287.     {
    288.  
    289.         if (check)
    290.  
    291.         {
    292.  
    293.             //判断题目对错
    294.  
    295.             bool isRight;
    296.  
    297.             int idx = ArrayX[randomNum[topicIndex]].Length - 1;
    298.  
    299.             int n = int.Parse(ArrayX[randomNum[topicIndex]][idx]) - 1;
    300.  
    301.             if (n == index)
    302.  
    303.             {
    304.  
    305.                 tipsText.text = "" + "恭喜你，答对了！" + "";
    306.  
    307.                 isRight = true;
    308.  
    309.                 tipsbtn.SetActive(true);
    310.  
    311.             }
    312.  
    313.             else
    314.  
    315.             {
    316.  
    317.                 tipsText.text = "" + "对不起，答错了！" + "";
    318.  
    319.                 isRight = false;
    320.  
    321.                 tipsbtn.SetActive(true);
    322.  
    323.             }
    324.  
    325.  
    326.  
    327.             //正确率计算
    328.  
    329.             if (isAnserList[randomNum[topicIndex]])
    330.  
    331.             {
    332.  
    333.                 tipsText.text = "" + "这道题已答过！" + "";
    334.  
    335.             }
    336.  
    337.             else
    338.  
    339.             {
    340.  
    341.                 anserint++;
    342.  
    343.                 if (isRight)
    344.  
    345.                 {
    346.  
    347.                     isRightNum++;
    348.  
    349.                 }
    350.  
    351.                 isAnserList[randomNum[topicIndex]] = true;
    352.  
    353.                 TextAccuracy.text = "正确率：" + ((float)isRightNum / anserint * 100).ToString("f2") + "%";
    354.  
    355.             }
    356.  
    357.  
    358.  
    359.             //禁用掉选项
    360.  
    361.             for (int i = 0; i < toggleList.Count; i++)
    362.  
    363.             {
    364.  
    365.                 toggleList[i].interactable = false;
    366.  
    367.             }
    368.  
    369.         }
    370.  
    371.     }
    372.  
    373.     /*****************获得随机数******************/
    374.  
    375.     void GetRandomNum()
    376.  
    377.     {
    378.  
    379.         HashSet<int> nums = new HashSet<int>();
    380.  
    381.         System.Random r = new System.Random();
    382.  
    383.         while (nums.Count != topicMax)
    384.  
    385.         {
    386.  
    387.             nums.Add(r.Next(0, topicMax));
    388.  
    389.         }
    390.  
    391.         //Debug.Log(topicMax);
    392.  
    393.         foreach (var item in nums)
    394.  
    395.         {
    396.  
    397.             randomNum.Add(item);
    398.  
    399.         }
    400.  
    401.     }
    402.  
    403. }

    2，用Unity做一个局域网游戏(上)

    1. using System.Net;
    2.  
    3. using System.Net.Sockets;
    4.  
    5. using System.IO;
    6.  
    7. using System.Runtime.Serialization.Formatters.Binary;
    8.  
    9. using System.Text;
    10.  
    11. /// 
    12.  
    13. /// 网络工具类 
    14.  
    15. /// 
    16.  
    17. public static class NetworkUtils
    18.  
    19. {
    20.  
    21.     //序列化：obj -> byte[]
    22.  
    23.     public static byte[] Serialize(object obj)
    24.  
    25.     {
    26.  
    27.         //对象必须被标记为Serializable
    28.  
    29.         if (obj == null || !obj.GetType().IsSerializable)
    30.  
    31.             return null;
    32.  
    33.         BinaryFormatter formatter = new BinaryFormatter();
    34.  
    35.         using (MemoryStream stream = new MemoryStream())
    36.  
    37.         {
    38.  
    39.             formatter.Serialize(stream, obj);
    40.  
    41.             byte[] data = stream.ToArray();
    42.  
    43.             return data;
    44.  
    45.         }
    46.  
    47.     }
    48.  
    49.  
    50.  
    51.     //反序列化：byte[] -> obj
    52.  
    53.     public static T Deserialize<T>(byte[] data) where T : class
    54.  
    55.     {
    56.  
    57.         //T必须是可序列化的类型
    58.  
    59.         if (data == null || !typeof(T).IsSerializable)
    60.  
    61.             return null;
    62.  
    63.         BinaryFormatter formatter = new BinaryFormatter();
    64.  
    65.         using (MemoryStream stream = new MemoryStream(data))
    66.  
    67.         {
    68.  
    69.             object obj = formatter.Deserialize(stream);
    70.  
    71.             return obj as T;
    72.  
    73.         }
    74.  
    75.     }
    76.  
    77. } 
    1. /// 
    2.  
    3.     /// 棋子类型
    4.  
    5.     /// 
    6.  
    7.     public enum Chess
    8.  
    9.     {
    10.  
    11.         //棋子类型
    12.  
    13.         None, //空棋
    14.  
    15.         Black,//黑棋
    16.  
    17.         White,//白棋
    18.  
    19.  
    20.  
    21.         //以下用于胜利判断结果和操作结果
    22.  
    23.         Draw, //平局
    24.  
    25.         Null, //表示无结果(用于用户操作失败情况下的返回值)
    26.  
    27.     }
    1. /// 
    2.  
    3.     /// 消息类型
    4.  
    5.     /// 
    6.  
    7.     public enum MessageType
    8.  
    9.     {
    10.  
    11.         None,         //空类型
    12.  
    13.         HeartBeat,    //心跳包验证
    14.  
    15.        
    16.  
    17.         //以下为玩家操作请求类型
    18.  
    19.         Enroll,       //注册
    20.  
    21.         CreatRoom,    //创建房间
    22.  
    23.         EnterRoom,    //进入房间
    24.  
    25.         ExitRoom,     //退出房间
    26.  
    27.         StartGame,    //开始游戏
    28.  
    29.         PlayChess,    //下棋
    30.  
    31.     }

    每种玩家操作请求类型都对应一个类（Class），这个类包含客户端向服务器发送的属性，也包含服务器向客户端回应的属性。

    以创建房间为例：

    [Serializable]         //加上C#自带的可序列化特性就可以把该类型序列化了

        public class CreatRoom

        {

            public int RoomId; //房间号码,客户端向服务器发送的属性

            public bool Suc;   //是否成功,服务器向客户端发送的属性

        }

    由于协议类型过多，这里只展示一种协议的序列化与反序列化。

    byte[] data = NetworkUtils.Serialize(new CreatRoom(){ RoomId = 8848 }); //序列化

    CreatRoom room =  NetworkUtils.Deserialize(data); 

    首先我们用VisualStudio创建一个消息协议的C#类库项目.


    然后在项目属性里面把输出类型改为类库（DLL）。

    对于unity版本低于2017的，应该把目标框架改为.Net Framework 3.5及以下
    然后建立一个命名空间：Multiplay，并把上面的协议类型枚举放在命名空间中即可。

    以下客户端向服务器之间协议的具体类型：

    1. [Serializable]
    2.  
    3.     public class Enroll
    4.  
    5.     {
    6.  
    7.         public string Name;//姓名
    8.  
    9.  
    10.  
    11.         public bool Suc;   //是否成功
    12.  
    13.     }
    14.  
    15.  
    16.  
    17.     [Serializable]
    18.  
    19.     public class CreatRoom
    20.  
    21.     {
    22.  
    23.         public int RoomId; //房间号码
    24.  
    25.  
    26.  
    27.         public bool Suc;   //是否成功
    28.  
    29.     }
    30.  
    31.  
    32.  
    33.     [Serializable]
    34.  
    35.     public class EnterRoom
    36.  
    37.     {
    38.  
    39.         public int RoomId;      //房间号码
    40.  
    41.  
    42.  
    43.         public Result result;   //结果
    44.  
    45.         public enum Result
    46.  
    47.         {
    48.  
    49.             None,
    50.  
    51.             Player,
    52.  
    53.             Observer,
    54.  
    55.         }
    56.  
    57.     }
    58.  
    59.  
    60.  
    61.     [Serializable]
    62.  
    63.     public class ExitRoom
    64.  
    65.     {
    66.  
    67.         public int RoomId;  //房间号码
    68.  
    69.  
    70.  
    71.         public bool Suc;    //是否成功
    72.  
    73.     }
    74.  
    75.  
    76.  
    77.     [Serializable]
    78.  
    79.     public class StartGame
    80.  
    81.     {
    82.  
    83.         public int RoomId;            //房间号码
    84.  
    85.  
    86.  
    87.         public bool Suc;              //是否成功
    88.  
    89.         public bool First;            //是否先手
    90.  
    91.         public bool Watch;            //是否是观察者
    92.  
    93.     }
    94.  
    95.  
    96.  
    97.     [Serializable]
    98.  
    99.     public class PlayChess
    100.  
    101.     {
    102.  
    103.         public int RoomId;       //房间号码
    104.  
    105.         public Chess Chess;      //棋子类型
    106.  
    107.         public int X;            //棋子坐标
    108.  
    109.         public int Y;            //棋子坐标
    110.  
    111.  
    112.  
    113.         public bool Suc;         //操作结果
    114.  
    115.         public Chess Challenger; //胜利者
    116.  
    117.     }

      

    获取IP地址

    在此介绍网络通信之前，我们编写一个方法并放在之前的NetworkUtils类中，可以快速获得本机IPv4地址（用于表示在网络上的位置），不然就得在cmd中手动输入ipconfig指令查看本机IPv4地址。在之后需要IPv4地址的时候，直接调用该方法即可，代码如下：

    ///

        /// 获取本机IPv4,获取失败则返回null

        ///

        public static string GetLocalIPv4()

        {

            string hostName = Dns.GetHostName(); //得到主机名

            IPHostEntry iPEntry = Dns.GetHostEntry(hostName);

            for (int i = 0; i < iPEntry.AddressList.Length; i++)

            {

                //从IP地址列表中筛选出IPv4类型的IP地址

                if (iPEntry.AddressList[i].AddressFamily == AddressFamily.InterNetwork)

                    return iPEntry.AddressList[i].ToString();

            }

            return null;

        }

    OK，有了这些工具并知道了基础的概念，那么如何实现网络通信？

    我们是基于TCP/IP协议在不同计算机之间进行网络通讯，但是我们总得有一个可以用C#调用的接口：就是服务器跟客户端进行网络操作的API方法。在System.Net.Sockets下，C#为我们贴心地封装了一个网络通讯的API类型：Socket（网络套接字）类型。

    服务器网络

    我们首先创建一个静态类：Server，其中包含服务器的所有网络操作。


    在Server提供一个Start方法用于实例化Socket对象：

    //实例化Socket类型 参数1:使用ipv4进行寻址 参数2:使用流进行数据传输 参数3:基于TCP协议

    Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

    创建好socket对象之后需要把socket对象与IP终端对象（包含IP地址与端口号）进行绑定。以此确定服务器在网络空间中的位置与服务器这个程序所用的端口号。

    如果把IP地址比作一间房子 ，端口就是出入这间房子的门。
    使用端口号，可以找到一台设备上唯一的一个程序。 所以如果需要和某台计算机建立连接的话，只需要知道IP地址或域名即可，但是如果想和该台计算机上的某个程序交换数据的话，还必须知道该程序使用的端口号。


    //IP终端

    IPEndPoint point = new IPEndPoint(IPAddress.Parse(ip), 8848);

    socket.Bind(point); //套接字绑定IP终端

    socket.Listen(0);   //开始监听来自其他计算机的连接

    通过以上操作，服务器的Socket就已经具备监听其他计算机网络连接的功能了，接下来就准备实现服务器最核心的功能：等待客户端连接，接收客户端数据。

    服务器概念

    服务器采用开房间（Room）的机制（比如LOL中的一局比赛）进行游戏，并且会有一个集合保存所有玩家（Player）的，有一个字典保存所有房间，有一个回调方法队列。

    先上一波Server类的数据结构：

    using Multiplay; //使用协议

    ///

    ///

    ///

    public static class Server

    {

        public static Dictionary Rooms;                  //游戏房间集合

        public static List Players;                         //玩家集合

        private static Socket _serverSocket;                        //服务器socket

    }

    稍后会介绍并用到这些属性与类型。

    虽然服务器直接利用TCP协议与客户端进行长连接，但是服务器除了会保存玩家状态，数据收发逻辑与HTTP相似。在HTTP中，服务器不会保存客户端的状态，也不会主动向客户端发送信息，只有在客户端向服务器请求数据的时候，服务器才会向客户端发送响应数据。

    关于HTTP与TCP/IP可参考：（HTTP与TCP的区别和联系 - CSDN博客）https://blog.csdn.net/u013485792/article/details/52100533

    我们首先制作两个关键的数据类型用于保存关键数据。

    服务器数据类型

    Player类型，包含客户端Socket与玩家的基本信息：

    public class Player

    {

        public Socket Socket; //网络套接字

        public string Name;   //玩家名字

        public bool InRoom;   //是否在房间中

        public int RoomId;    //所处房间号码

        public Player(Socket socket)

        {

            Socket = socket;

            Name = "Player Unknown";

            InRoom = false;

            RoomId = 0;

        }

        public void EnterRoom(int roomId)

        {

            InRoom = true;

            RoomId = roomId;

        }

        public void ExitRoom()

        {

            InRoom = false;

        }

    }

    Room类型，包含房间号码，房间状态，容纳人数，玩家与观察者的集合：

    public class Room

    {

        public enum RoomState

        {

            Await,  //等待

            Gaming  //对局开始

        }

        //房间ID

        public int RoomId = 0;

        //房间棋盘信息

        public GamePlay GamePlay;

        //房间状态

        public RoomState State = RoomState.Await;

        //最大玩家数量

        public const int MAX_PLAYER_AMOUNT = 2;

        //最大观察者数量

        public const int MAX_OBSERVER_AMOUNT = 2;

        public List Players = new List(); //玩家集合

        public List OBs = new List();     //观察者集合

        public Room(int roomId)                           //构造

        {

            RoomId = roomId;

            GamePlay = new GamePlay();

        }

    }

    等待客户端连接

    服务器的思路就是：开启服务器监听后，先开启一个线程（Thread）不断接受（Accept）客户端Socket的连接。每当有一个客户端连接上服务器，服务器会获取客户端的Socket并且启动一个线程去接收（Receive）这个客户端发送的信息。

    服务器上一旦发生异常且没有处理，等于服务器直接挂掉。所有连接上服务器的客户端全部会失去连接。所以对于服务器来说要非常谨慎地编写关键部分的代码。

    我们继续在Server类中编写，以下是等待客户端代码：

            //在初始化方法中开启等待玩家线程

            Thread thread = new Thread(_Await) { IsBackground = true };

            thread.Start();

        //等待客户端方法

        private static void _Await()

        {

            Socket client = null;

            while (true)

            {

                try

                {

                    //同步等待,程序会阻塞在这里

                    client = _serverSocket.Accept();

                    //获取客户端唯一键

                    string endPoint = client.RemoteEndPoint.ToString();

                    //新增玩家

                    Player player = new Player(client);

                    Players.Add(player);

                    Console.WriteLine($"{player.Socket.RemoteEndPoint}连接成功");

                    //创建特定类型的方法

                    ParameterizedThreadStart receiveMethod =

                       new ParameterizedThreadStart(_Receive);  //Receive方法在后面实现

                    Thread listener = new Thread(receiveMethod) { IsBackground = true };

                   

                    listener.Start(player); //开启一个线程监听该客户端发送的消息

                }

                catch (Exception ex)

                {

                    Console.WriteLine(ex.Message);

                }

            }

        } 

    1.  /// 
    2.  
    3.     /// 封装数据
    4.  
    5.     /// 
    6.  
    7.     private static byte[] _Pack(MessageType type, byte[] data = null)
    8.  
    9.     {
    10.  
    11.         List<byte> list = new List<byte>();
    12.  
    13.         if (data != null)
    14.  
    15.         {
    16.  
    17.             list.AddRange(BitConverter.Getbytes((ushort)(4 + data.Length)));//消息长度2字节
    18.  
    19.             list.AddRange(BitConverter.Getbytes((ushort)type));             //消息类型2字节
    20.  
    21.             list.AddRange(data);                                            //消息内容n字节
    22.  
    23.         }
    24.  
    25.         else
    26.  
    27.         {
    28.  
    29.             list.AddRange((ushort)4);                         //消息长度2字节
    30.  
    31.             list.AddRange((ushort)type);                      //消息类型2字节
    32.  
    33.         }
    34.  
    35.         return packer.ToArray();
    36.  
    37.     } 
    1. //回调委托
    2.  
    3. public delegate void ServerCallBack(Player client, byte[] data);
    4.  
    5.  
    6.  
    7. //回调类型
    8.  
    9. public class CallBack
    10.  
    11. {
    12.  
    13.     public Player Player;
    14.  
    15.  
    16.  
    17.     public byte[] Data;
    18.  
    19.  
    20.  
    21.     public ServerCallBack ServerCallBack;
    22.  
    23.  
    24.  
    25.     public CallBack(Player player, byte[] data, ServerCallBack serverCallBack)
    26.  
    27.     {
    28.  
    29.         Player = player;
    30.  
    31.         Data = data;
    32.  
    33.         ServerCallBack = serverCallBack;
    34.  
    35.     }
    36.  
    37.  
    38.  
    39.     public void Execute()
    40.  
    41.     {
    42.  
    43.         ServerCallBack(Player, Data);
    44.  
    45.     }
    46.  
    47. }

    private static ConcurrentQueue _callBackQueue;          //回调方法队列

        private static Dictionary _callBacks

            = new Dictionary();              //消息类型与回调方法

        ///

        /// 注册消息回调事件

        ///

        public static void Register(MessageType type, ServerCallBack method)

        {

            if (!_callBacks.ContainsKey(type))

                _callBacks.Add(type, method);

            else

                Console.WriteLine("注册了相同的回调事件");

        }

    并且在服务器启动之前就把回调方法注册好，以下方法写在一个新的类型：Network中：

        ///

        /// 启动服务器

        ///

        /// IPv4地址

        public Network(string ip)

        {

            //注册

            Server.Register(MessageType.HeartBeat, _HeartBeat);

            Server.Register(MessageType.Enroll, _Enroll);

            Server.Register(MessageType.CreatRoom, _CreatRoom);

            Server.Register(MessageType.EnterRoom, _EnterRoom);

            Server.Register(MessageType.ExitRoom, _ExitRoom);

            Server.Register(MessageType.StartGame, _StartGame);

            Server.Register(MessageType.PlayChess, _PlayChess);

            //启动服务器

            Server.Start(ip);

        } 

    1. //在开启Await线程后,开启回调方法线程
    2.  
    3.         Thread handle = new Thread(_Callback) { IsBackground = true };
    4.  
    5.         handle.Start();
    6.  
    7.  
    8.  
    9.     private static void _Callback()
    10.  
    11.     {
    12.  
    13.         while (true)
    14.  
    15.         {
    16.  
    17.             if (_callBackQueue.Count > 0)
    18.  
    19.             {
    20.  
    21.                 //使用TryDequeue保证线程安全
    22.  
    23.                 if (_callBackQueue.TryDequeue(out CallBack callBack))
    24.  
    25.                 {
    26.  
    27.                     //执行回调
    28.  
    29.                     callBack.Execute();
    30.  
    31.                 }
    32.  
    33.             }
    34.  
    35.             //让出线程
    36.  
    37.             Thread.Sleep(10);
    38.  
    39.         }
    40.  
    41.     }
    1.  private static void _Receive(object obj)
    2.  
    3.     {
    4.  
    5.         Player player = obj as Player;
    6.  
    7.         Socket client = player.Socket;
    8.  
    9.        
    10.  
    11.         //持续接受消息
    12.  
    13.         while (true)
    14.  
    15.         {
    16.  
    17.             //解析数据包过程(服务器与客户端需要严格按照一定的协议制定数据包)
    18.  
    19.             byte[] data = new byte[4];
    20.  
    21.  
    22.  
    23.             int length = 0;                            //消息长度
    24.  
    25.             MessageType type = MessageType.None;       //类型
    26.  
    27.             int receive = 0;                           //接收信息
    28.  
    29.  
    30.  
    31.             try
    32.  
    33.             {
    34.  
    35.                 receive = client.Receive(data); //同步接受消息
    36.  
    37.             }
    38.  
    39.             catch (Exception ex)
    40.  
    41.             {
    42.  
    43.                 Console.WriteLine($"{client.RemoteEndPoint}已掉线:{ex.Message}");
    44.  
    45.                 player.Offline();
    46.  
    47.                 return;
    48.  
    49.             }
    50.  
    51.  
    52.  
    53.             //包头接收不完整
    54.  
    55.             if (receive < data.Length)
    56.  
    57.             {
    58.  
    59.                 Console.WriteLine($"{client.RemoteEndPoint}已掉线");
    60.  
    61.                 player.Offline();
    62.  
    63.                 return;
    64.  
    65.             }
    66.  
    67.  
    68.  
    69.             //解析消息过程
    70.  
    71.             using (MemoryStream stream = new MemoryStream(data))
    72.  
    73.             {
    74.  
    75.                 BinaryReader binary = new BinaryReader(stream, Encoding.UTF8);
    76.  
    77.                 try
    78.  
    79.                 {
    80.  
    81.                     length = binary.ReadUInt16();
    82.  
    83.                     type = (MessageType)binary.ReadUInt16();
    84.  
    85.                 }
    86.  
    87.                 catch (Exception)
    88.  
    89.                 {
    90.  
    91.                     Console.WriteLine($"{client.RemoteEndPoint}已掉线");
    92.  
    93.                     player.Offline();
    94.  
    95.                     return;
    96.  
    97.                 }
    98.  
    99.             }
    100.  
    101.  
    102.  
    103.             //如果有包体
    104.  
    105.             if (length - 4 > 0)
    106.  
    107.             {
    108.  
    109.                 data = new byte[length - 4];
    110.  
    111.                 receive = client.Receive(data);
    112.  
    113.                 if (receive < data.Length)
    114.  
    115.                 {
    116.  
    117.                     Console.WriteLine($"{client.RemoteEndPoint}已掉线");
    118.  
    119.                     player.Offline();
    120.  
    121.                     return;
    122.  
    123.                 }
    124.  
    125.             }
    126.  
    127.             else
    128.  
    129.             {
    130.  
    131.                 data = new byte[0];
    132.  
    133.                 receive = 0;
    134.  
    135.             }
    136.  
    137.  
    138.  
    139.             Console.WriteLine($"接受到消息, 房间数:{Rooms.Count}, 玩家数:{Players.Count}");
    140.  
    141.  
    142.  
    143.             //回调机制机制
    144.  
    145.             if (_callBacks.ContainsKey(type))
    146.  
    147.             {
    148.  
    149.                 CallBack callBack = new CallBack(player, data, _callBacks[type]);
    150.  
    151.                 //放入回调队列
    152.  
    153.                 _callBackQueue.Enqueue(callBack);
    154.  
    155.             }
    156.  
    157.         }
    158.  
    159.     }

    客户端网络

    连接服务器

    创建好unity工程后先新建一个NetworkClient脚本直奔主题先。

    首先要想该利用那些C#API连接上服务器呢？又如何向服务器收发数据？恩，在这里使用C#的API：TcpClient（连接服务器建立数据流），NetworkStream（在数据流中读写数据）

    在NetworkClient脚本中，我们取消继承Monobehaviour而是把这个类型设置为静态类型。


    与服务器类似，客户端也有消息回调字典，与一个待发送消息队列，需要发送消息只需把消息添加进这个队列，然后提供有专门的协程（Coroutine）去发送。

    以下是部分NetworkClient类的部分属性：

        using Multiplay; //使用协议

        ///

        /// 客户端网络状态枚举

        ///

        private enum ClientState

        {

            None,        //未连接

            Connected,   //连接成功

        }

        //消息类型与回调字典

        private static Dictionary _callBacks =

            new Dictionary();

        //待发送消息队列

        private static Queue _messages;

        //当前状态

        private static ClientState _curState;

        //向服务器建立TCP连接并获取网络通讯流

        private static TcpClient _client;

        //在网络通讯流中读写数据

        private static NetworkStream _stream;

        //目标ip

        private static IPAddress _address;

        //端口号

        private static int _port;

    连接服务器之前肯定要先确定服务器的ip地址，端口号服务器跟客户端使用一个自定义的就行（0-65536），最好是8848这种比较靠后的数字，像1024之前的多半被操作系统分配给了其他应用程序。以下是ip地址与端口号初始化方法：


        ///

        /// 初始化网络客户端

        ///

        public static void Init(string address = null, int port = 8848)

        {

            //连接上后不能重复连接

            if (_curState == ClientState.Connected)

                return;

            //如果为空则默认连接本机ip的服务器

            if (address == null)

                address = NetworkUtils.GetLocalIPv4();

            //类型获取失败则取消连接

            if (!IPAddress.TryParse(address, out _address))

                return;

        }

    因为客户端同时担任收发数据的责任，我们得在Unity的不同协程（利用C#迭代器实现的类似Update的机制）中同时收发数据。

    Unity协程中不建议用同步方法，大部分同步方法会主线程阻塞或导致死循环
    因为NetworkClient类型是静态类型，无法直接使用StartCoroutine，因此我们可以提供一个继承自Monobehaviour的类型去提供这个方法。

    以下是这个类型的实现，使用单例模式，提供一个程序退出时调用的委托来关闭网络连接：

        public class NetworkCoroutine : MonoBehaviour

        {

            public Action ApplicationQuitEvent;

            private static NetworkCoroutine _instance;

            // 场景单例(不随场景改变而销毁)

            public static NetworkCoroutine Instance

            {

                get

                {

                    if (!_instance)

                    {

                        GameObject socketClientObj = new GameObject("NetworkCoroutine");

                        _instance = socketClientObj.AddComponent();

                        DontDestroyOnLoad(socketClientObj);

                    }

                    return _instance;

                }

            }

            // 程序退出

            private void OnApplicationQuit()

            {

                if (ApplicationQuitEvent != null)

                    ApplicationQuitEvent();

            }

         }

    然后我们在NetworkClient创建一个连接服务器的方法（Connect），下面是关键代码：

            //以下代码放在一个叫Connect的协程方法中

            _client = new TcpClient();

            //异步连接服务器

            IAsyncResult async = _client.BeginConnect(_address, _port, null, null);

            while (!async.IsCompleted)

            {

                Debug.Log("连接服务器中");

                yield return null;

            }

            //结束异步

            _client.EndConnect(async);

            //获取网络流

            _stream = _client.GetStream();

            _curState = ClientState.Connected;

            _messages = new Queue();

            Debug.Log("连接服务器成功");

            //设置异步发送消息

            NetworkCoroutine.Instance.StartCoroutine(_Send());

            //设置异步接收消息

            NetworkCoroutine.Instance.StartCoroutine(_Receive());

            //设置退出事件

            NetworkCoroutine.Instance.ApplicationQuitEvent +=

               () => { _client.Close(); _curState = ClientState.None; };

    现在我们启动服务器，并在客户端新建一个Network类型脚本，放在场景中，然后可以在Start方法中调用NetworkClient的连接服务器方法尝试连接服务器。

    好了。到目前为止，我们已经实现了消息的序列化、服务器房间的搭建以及服务器与客户端的基本通信。


    介于字数原因，客户端gameplay部分与收发数据操作放在下一篇介绍。

  • 相关阅读:
    Toronto Research Chemicals单羟基舒更葡糖钠说明书
    蓝桥杯打卡Day11
    【C++入门到精通】 哈希结构 | 哈希冲突 | 哈希函数 | 闭散列 | 开散列 [ C++入门 ]
    App移动测试，这样学最有效
    到底要不要写注释？
    3、Pinpoint-Agent端注册服务到Server端
    Activity7-BPMN介绍
    【Linux环境搭建】五、Linux(CentOS7)编译源码安装Subversion
    Linux C++，使用log4cpp记录日志示例详解
    JavaWeb以Maven整合Mybatis报错java.lang.NoClassDefFoundError（Web项目未能完全加载Maven下的依赖）
  • 原文地址：https://blog.csdn.net/m0_69824302/article/details/127762248