devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity组件开发--长连接webSocket_comfyui websocket

作者：凡人多烦事01 | 2024-02-18 10:33:28

赞

踩

comfyui websocket

1.下载安装UnityWebSocket 插件

https://gitee.com/cambright/UnityWebSocket/

引入unity项目：

2.定义消息体结构：ExternalMessage和包结构Package：

  1. using ProtoBuf;
  2. using System;
  3. using System.Collections;
  4. using System.Collections.Generic;
  5. using UnityEngine;
  6.  
  7. namespace UTNET
  8. {
  9.  
  10.     [ProtoContract]
  11.     public class ExternalMessage
  12.     {
  13.         [ProtoMember(1)]
  14.         // 请求命令类型: 0 心跳，1 业务
  15.         public int cmdCode;
  16.         // 协议开关，用于一些协议级别的开关控制，比如 安全加密校验等。 : 0 不校验
  17.         [ProtoMember(2)]
  18.         public int protocolSwitch;
  19.         // 业务路由（高16为主, 低16为子）
  20.         [ProtoMember(3)]
  21.         public uint cmdMerge;
  22.         // 响应码: 0:成功, 其他为有错误
  23.         [ProtoMember(4,DataFormat = DataFormat.ZigZag)]
  24.         public int responseStatus;
  25.         // 验证信息（错误消息、异常消息），通常情况下 responseStatus == -1001 时， 会有值
  26.         [ProtoMember(5)]
  27.         public string validMsg;
  28.         // 业务请求数据
  29.         [ProtoMember(6)]
  30.         public byte[] data;
  31.         // 消息标记号；由前端请求时设置，服务器响应时会携带上；
  32.         [ProtoMember(7, DataFormat = DataFormat.ZigZag)]
  33.         public int msgId;
  34.     }
  35.  
  36.  
  37.     [ProtoContract]
  38.     public class Package
  39.     {
  40.         [ProtoMember(1)]
  41.         public uint packageType;
  42.  
  43.         [ProtoMember(2)]
  44.         public string route = null;
  45.  
  46.         [ProtoMember(3)]
  47.         public uint packID = 0;
  48.  
  49.         [ProtoMember(4)]
  50.         public byte[] buff = null;
  51.  
  52.         [ProtoMember(5)]
  53.         public string modelName = null;
  54.     }
  55.  
  56.     //[ProtoContract]
  57.     //public class Message<T>
  58.     //{
  59.     //    [ProtoMember(1)]
  60.     //    public uint err;
  61.     //    [ProtoMember(2)]
  62.     //    public string errMsg = default;
  63.     //    [ProtoMember(3)]
  64.     //    public T data = default;
  65.     //    public Message() { }
  66.     //    public Message(uint err, string errMsg, T info)
  67.     //    {
  68.     //        this.err = err;
  69.     //        this.errMsg = errMsg;
  70.     //        this.data = info;
  71.     //    }
  72.     //}
  73.  
  74.     [ProtoContract]
  75.     public class HandShake
  76.     {
  77.         [ProtoMember(1)]
  78.         public string token;
  79.     }
  80.  
  81.     [ProtoContract]
  82.     public class Heartbeat
  83.     {
  84.         [ProtoMember(1)]
  85.         public uint heartbeat;
  86.     }
  87. }

3.定义包协议结构：PackageProtocol

  1. using ProtoBuf;
  2. using System;
  3. using System.IO;
  4. using System.Text;
  5. using UnityEngine.XR;
  6.  
  7. namespace UTNET
  8. {
  9.     public enum PackageType
  10.     {
  11.         HEARTBEAT = 1,
  12.         REQUEST = 2,
  13.         PUSH = 3,
  14.         KICK = 4,
  15.         RESPONSE = 5,
  16.         HANDSHAKE = 6,
  17.         ERROR = 7,
  18.         NOTIFY = 8
  19.     }
  20.  
  21.     public class PackageProtocol
  22.     {
  23.         //获取cmd
  24.         public static uint getCmd(uint merge)
  25.         {
  26.             return merge >> 16;
  27.         }
  28.         //获取subCmd
  29.         public static uint getSubCmd(uint merge)
  30.         {
  31.             return merge & 0xFFFF;
  32.         }
  33.         //获取mergeCmd
  34.         public static uint getMergeCmd(uint cmd, uint subCmd)
  35.         {
  36.             return (cmd << 16) + subCmd;
  37.         }
  38.         public static byte[] Encode(PackageType type)
  39.         {
  40.             Package sr = new Package()
  41.             {
  42.                 packageType = (uint)type
  43.             };
  44.             return Serialize(sr);
  45.         }
  46.  
  47.         public static byte[] Encode<T>(PackageType type, uint packID, string route, T info, string modelName = null)
  48.         {
  49.             Package sr = new Package()
  50.             {
  51.                 packageType = (uint)type,
  52.                 packID = packID,
  53.                 route = route,
  54.                 buff = Serialize<T>(info),
  55.                 modelName = modelName
  56.             };
  57.             return Serialize(sr);
  58.         }
  59.  
  60.  
  61.         public static byte[] EncodeEx<T>(uint packID, uint cmdMerge, T info)
  62.         {
  63.             //Package sr = new Package()
  64.             //{
  65.             //    packageType = (uint)type,
  66.             //    packID = packID,
  67.             //    route = route,
  68.             //    buff = Encoding.Default.GetBytes(SerializeEx<T>(info)),
  69.             //};
  70.             //return SerializeEx(sr);
  71.  
  72.             ExternalMessage sr = new ExternalMessage()
  73.             {
  74.                 cmdCode = 100,
  75.                 protocolSwitch = 1,
  76.                 cmdMerge = cmdMerge,
  77.                 responseStatus = 0,
  78.                 validMsg = "",
  79.                 data = Encoding.UTF8.GetBytes(SerializeEx<T>(info)),
  80.             };
  81.             return Serialize(sr);
  82.  
  83.         }
  84.  
  85.  
  86.  
  87.         public static byte[] Encode<T>(uint packID, uint cmdMerge, T info)
  88.         {
  89.             ExternalMessage sr = new ExternalMessage()
  90.             {
  91.                 cmdCode = 100,
  92.                 protocolSwitch = 1,
  93.                 cmdMerge = cmdMerge,
  94.                 responseStatus = 0,
  95.                 validMsg = "",
  96.                 data = Serialize<T>(info),
  97.                 msgId = (int)packID,
  98.             };
  99.             return Serialize(sr);
  100.         }
  101.  
  102.         public static string SerializeEx<T>(T t)
  103.         {
  104.             using (MemoryStream ms = new MemoryStream())
  105.             {
  106.                 Serializer.Serialize<T>(ms, t);
  107.                 return Encoding.UTF8.GetString(ms.ToArray());
  108.             }
  109.         }
  110.  
  111.  
  112.         public static byte[] Serialize<T>(T info)
  113.         {
  114.             if (typeof(T) == typeof(int))
  115.             {
  116.                 int value = (int)Convert.ChangeType(info, typeof(int));
  117.                 value = (value << 1);
  118.                 info = (T)Convert.ChangeType(info, typeof(T));
  119.             }
  120.  
  121.             MemoryStream ms = new MemoryStream();
  122.             Serializer.Serialize(ms, info);
  123.             byte[] buff = ms.ToArray();
  124.             ms.Close();
  125.             return buff;
  126.  
  127.             //try
  128.             //{
  129.             //    //涉及格式转换，需要用到流，将二进制序列化到流中
  130.             //    using (MemoryStream ms = new MemoryStream())
  131.             //    {
  132.             //        //使用ProtoBuf工具的序列化方法
  133.             //        Serializer.Serialize<T>(ms, info);
  134.             //        //定义二级制数组，保存序列化后的结果
  135.             //        byte[] result = new byte[ms.Length];
  136.             //        //将流的位置设为0，起始点
  137.             //        ms.Position = 0;
  138.             //        //将流中的内容读取到二进制数组中
  139.             //        ms.Read(result, 0, result.Length);
  140.             //        return result;
  141.             //    }
  142.             //}
  143.             //catch (Exception ex)
  144.             //{
  145.             //    return null;
  146.             //}
  147.  
  148.  
  149.  
  150.         }
  151.  
  152.         public static ExternalMessage Decode(byte[] buff)
  153.         {
  154.             //protobuf反序列化
  155.             MemoryStream mem = new MemoryStream(buff);
  156.             ExternalMessage rs = Serializer.Deserialize<ExternalMessage>(mem);
  157.             mem.Close();
  158.             return rs;
  159.         }
  160.         public static T DecodeInfo<T>(byte[] buff)
  161.         {
  162.             if (buff == null) return default;
  163.             T rs;
  164.  
  165.             if (typeof(T) == typeof(int))
  166.             {
  167.                 int value;
  168.                 using (var stream = new MemoryStream(buff))
  169.                 {
  170.                     value = Serializer.Deserialize<int>(stream);
  171.                 }//转zig zag
  172.                 value = (value >> 1) ^ -(value & 1);
  173.  
  174.                 rs = (T)Convert.ChangeType(value, typeof(T));
  175.             }
  176.             else
  177.             {
  178.                 MemoryStream mem = new MemoryStream(buff);
  179.                 rs = Serializer.Deserialize<T>(mem);
  180.                 mem.Close();
  181.             }
  182.  
  183.             return rs;
  184.         }
  185.  
  186.  
  187.  
  188.         //public static T MyMethod<T>(byte[] buff) where T : Object
  189.         //{
  190.         //    return null;
  191.         //}
  192.  
  193.  
  194.  
  195.     }
  196. }

4.引入UniTask插件：UniTask中文使用指南(一) - 知乎

UniTask保姆级教程_unitask安装-CSDN博客

项目地址：GitHub - Cysharp/UniTask: Provides an efficient allocation free async/await integration for Unity.

5.定义协议索引管理，添加长连接的协议：ProtoMaps

  1.  
  2.  
  3.  
  4.  
  5. using System;
  6. using System.Collections.Generic;
  7.  
  8.  
  9. namespace UTNET
  10. {
  11.  
  12.  
  13.     public interface IProto
  14.     {
  15.  
  16.     }
  17.  
  18.  
  19.  
  20.     //R ��������, S ��������
  21.     //public class Proto<R, S> : IProto
  22.     public class Proto : IProto
  23.     {
  24.         public string name; //������
  25.         public uint mid { get; set; } //��id
  26.         public uint sid { get; set; } //��id
  27.  
  28.         public uint mergeid;
  29.         public int typ; //������
  30.         //public R r;
  31.         //public S s;
  32.  
  33.         public Proto(string name, uint mid, uint sid, int typ)
  34.         {
  35.             this.name = name;
  36.             this.mid = mid;
  37.             this.sid = sid;
  38.             this.typ = typ;
  39.         }
  40.     }
  41.  
  42.     public class ProtoMaps
  43.     {
  44.  
  45.         private static readonly ProtoMaps instance = new ProtoMaps();
  46.  
  47.  
  48.         public static ProtoMaps Instance
  49.         {
  50.             get { return instance; }
  51.         }
  52.  
  53.  
  54.         //public Dictionary<string, IProto> protos = new Dictionary<string, IProto>();
  55.  
  56.         public Dictionary<string, Proto> protos = new Dictionary<string, Proto>();
  57.  
  58.         public Dictionary<uint, Proto> id2proto = new Dictionary<uint, Proto>();
  59.  
  60.  
  61.         public void Add(string name, Proto pb)
  62.         {
  63.             protos.Add(name, pb);
  64.         }
  65.  
  66.         public void SortById()
  67.         {
  68.             foreach (var item in protos)
  69.             {
  70.                 var pb = item.Value;
  71.                 uint mergeid = PackageProtocol.getMergeCmd(pb.mid, pb.sid);
  72.                 pb.mergeid = mergeid;
  73.                 id2proto.Add(mergeid, pb);
  74.             }
  75.         }
  76.  
  77.  
  78.         public ProtoMaps()
  79.         {
  80.             this.Add("login", new Proto("login", 1, 2, 1));
  81.             this.Add("registerInfo", new Proto("registerInfo", 1, 1, 1));
  82.             this.Add("enterRoom", new Proto("enterRoom", 1, 13, 3));
  83.             this.Add("roleMove", new Proto("roleMove", 4, 3, 3));
  84.             //this.Add("onNewRoleEnter", new Proto("onNewRoleEnter", 7, 1, 2));
  85.             //服务器主动广播的角色退出
  86.             this.Add("roleExitRoom", new Proto("roleExitRoom", 7, 2, 2));
  87.             this.Add("talkMrg", new Proto("talkMrg", 1, 9, 3));
  88.            
  89.             //玩家点击的角色退出
  90.             this.Add("playerExitRoom", new Proto("playerExitRoom", 1, 5, 3));
  91.  
  92.  
  93.             this.Add("gameFrame", new Proto("gameFrame", 4, 2, 1));
  94.             this.Add("gameObjUsed", new Proto("gameObjUsed", 4, 4, 3));
  95.  
  96.             this.Add("getOtherInfo", new Proto("getOtherInfo", 1, 23, 1));
  97.  
  98.             this.Add("heatBeat", new Proto("heatBeat", 1, 120, 1));
  99.  
  100.  
  101.  
  102.             SortById();
  103.         }
  104.  
  105.         public Proto Name2Pb(string name)
  106.         {
  107.             //Proto pb = ProtoMaps.Instance.protos[name];
  108.             if (protos.ContainsKey(name))
  109.             {
  110.                 return protos[name];
  111.             }
  112.             return null;
  113.         }
  114.  
  115.         internal Proto GetByMergeId(uint cmdMerge)
  116.         {
  117.             if (id2proto.ContainsKey(cmdMerge))
  118.             {
  119.                 return id2proto[cmdMerge];
  120.             }
  121.             return null;
  122.         }
  123.     }
  124.  
  125.  
  126.  
  127.  
  128.  
  129. }

6.定义心跳协议类：HeartBeatServiceGameObject

  1. using System;
  2. using UnityEngine;
  3. using UnityWebSocket;
  4. namespace UTNET
  5. {
  6.     public class HeartBeatServiceGameObject : MonoBehaviour
  7.     {
  8.         public Action OnServerTimeout;
  9.         private WebSocket socket;
  10.         public float interval = 0;
  11.  
  12.         public long lastReceiveHeartbeatTime;
  13.  
  14.         void Start()
  15.         {
  16.             
  17.         }
  18.  
  19.         static DateTime dt = new DateTime(1970, 1, 1);
  20.         public static long GetTimestamp()
  21.         {
  22.             TimeSpan ts = DateTime.Now.ToUniversalTime() - dt;
  23.             return (long)ts.TotalSeconds;
  24.         }
  25.  
  26.         public float t;
  27.  
  28.         void Update()
  29.         {
  30.             t += Time.deltaTime;
  31.             if (t > interval)
  32.             {
  33.                 CheckAndSendHearbeat();
  34.                 t = 0;
  35.             }
  36.         }
  37.  
  38.         private void CheckAndSendHearbeat()
  39.         {
  40.             //檢查最後一次取得心跳包的時間是否小於客戶端心跳間隔時間
  41.             long curTime = GetTimestamp();
  42.             long intervalSec = curTime - lastReceiveHeartbeatTime;
  43.             if (intervalSec > interval)
  44.             {
  45.                 //Debug.Log(string.Format("XXXX CheckAndSendHearbeat：s1:{0} l:{1} s:{2}", curTime, lastReceiveHeartbeatTime, intervalSec));
  46.                 this.enabled = false;
  47.                 OnServerTimeout?.Invoke();
  48.             }
  49.             else
  50.             {
  51.                 //Debug.Log(string.Format(" CheckAndSendHearbeat：s1:{0} l:{1} s:{2}", curTime, lastReceiveHeartbeatTime, intervalSec));
  52.                 this.enabled = true;
  53.                 SendHeartbeatPack();
  54.             }
  55.         }
  56.  
  57.         public void HitHole()
  58.         {
  59.             lastReceiveHeartbeatTime = GetTimestamp();
  60.         }
  61.  
  62.         private void SendHeartbeatPack()
  63.         {
  64.             //lastSendHeartbeatPackTime = DateTime.Now;
  65.             byte[] package = PackageProtocol.Encode(
  66.                 PackageType.HEARTBEAT);
  67.             socket.SendAsync(package);//*/
  68.         }
  69.  
  70.         internal void Setup(uint interval, Action onServerTimeout, WebSocket socket)
  71.         {
  72.             this.socket = socket;
  73.             this.interval = (interval / 1000 )/2;
  74.             this.OnServerTimeout = onServerTimeout;
  75.             this.enabled = true;
  76.             SendHeartbeatPack();
  77.         }
  78.  
  79.         internal void ResetTimeout(uint interval)
  80.         {
  81.             this.enabled = true;
  82.             this.interval = (interval / 1000) / 2;
  83.             t = 0;
  84.             //long s1 = GetTimestamp();
  85.             //long s = (s1 - lastReceiveHeartbeatTime);
  86.             //Debug.Log(string.Format("ResetTimeout： s1:{0} l:{1} s:{2} s > interval:{3}", s1, lastReceiveHeartbeatTime, s, s > interval));
  87.             lastReceiveHeartbeatTime = GetTimestamp();
  88.             SendHeartbeatPack();
  89.         }
  90.  
  91.         internal void Stop()
  92.         {
  93.             this.enabled = false;
  94.             t = 0;
  95.         }
  96.     }
  97. }

7.定义协议类Protocol：

  1. using Cysharp.Threading.Tasks;
  2. using ProtoBuf;
  3. using System;
  4. using System.Collections.Generic;
  5. using System.IO;
  6. using System.Net;
  7. using System.Runtime.InteropServices;
  8. using System.Text;
  9. using UnityEditor;
  10. using UnityEngine;
  11. using UnityWebSocket;
  12.  
  13. namespace UTNET
  14. {
  15.     public class Protocol
  16.     {
  17.  
  18.         Dictionary<uint, Action<ExternalMessage>> packAction = new Dictionary<uint, Action<ExternalMessage>>();
  19.         UniTaskCompletionSource<bool> handshakeTcs;
  20.         Dictionary<uint, UniTaskCompletionSource<ExternalMessage>> packTcs = new Dictionary<uint, UniTaskCompletionSource<ExternalMessage>>();
  21.  
  22.         //Dictionary<uint, Action<T>> attention = new Dictionary<uint, Action<T>>();
  23.  
  24.         WebSocket socket;
  25.         public HeartBeatServiceGameObject heartBeatServiceGo;
  26.         public Action OnReconected;
  27.         public Action<string> OnError;
  28.  
  29.         public void SetSocket(WebSocket socket)
  30.         {
  31.             this.socket = socket;
  32.         }
  33.  
  34.         public UniTask<bool> HandsharkAsync(string token)
  35.         {
  36.             handshakeTcs = new UniTaskCompletionSource<bool>();
  37.             return handshakeTcs.Task;
  38.         }
  39.  
  40.         internal void Notify<T>(string route, T info)
  41.         {
  42.             byte[] packBuff = PackageProtocol.Encode<T>(
  43.                 PackageType.NOTIFY,
  44.                 0,
  45.                 route,
  46.                 info);
  47.             socket.SendAsync(packBuff);
  48.         }
  49.  
  50.  
  51.         public UniTask<ExternalMessage> RequestAsync<T>(uint packID, uint route, T info = default, string modelName = null)
  52.         {
  53.             lock (packTcs)
  54.             {
  55.                 UniTaskCompletionSource<ExternalMessage> pack = new UniTaskCompletionSource<ExternalMessage>();
  56.                 byte[] packBuff = PackageProtocol.Encode<T>(packID, route, info);
  57.                 packTcs.Add(packID, pack);
  58.  
  59.                 //packTcs.Add(route, pack); //暂不支持，同一协议多次发送
  60.                 //byte[] ints = System.BitConverter.GetBytes(IPAddress.HostToNetworkOrder(testInt));
  61.                 //ByteBuffer bbBuffer = ByteBuffer.wrap(bs);
  62.                 //bbBuffer.order(ByteOrder.BIG_ENDIAN);
  63.  
  64.                 socket.SendAsync(packBuff);
  65.  
  66.                 return pack.Task;
  67.             }
  68.         }
  69.  
  70.         public void CanceledAllUTcs()
  71.         {
  72.             lock (packTcs)
  73.             {
  74.                 foreach (var tcs in packTcs)
  75.                 {
  76.                     tcs.Value.TrySetCanceled();
  77.                 }
  78.                 packTcs.Clear();
  79.                 if(handshakeTcs!=null) handshakeTcs.TrySetCanceled();
  80.             }
  81.         }
  82.  
  83.         public async void OnReceive(byte[] bytes)
  84.         {
  85.             
  86.             try
  87.             {
  88.                 await UniTask.SwitchToMainThread();
  89.                 ExternalMessage package = PackageProtocol.Decode(bytes);
  90.                 uint mId = PackageProtocol.getCmd(package.cmdMerge);
  91.                 uint subId = PackageProtocol.getSubCmd(package.cmdMerge);
  92.  
  93.               
  94.  
  95.  
  96.                 Proto pb = ProtoMaps.Instance.GetByMergeId(package.cmdMerge);
  97.                 if (package.responseStatus != 0)
  98.                 {
  99.                     Debug.LogError("收到 cmd:" + mId + " &subcmd:" + subId);
  100.                     Debug.LogError("收到网络消息  " + package.cmdMerge);
  101.  
  102.                     Debug.LogError("协议返回错误信息，查询errcode，后面可能根据弹窗处理: Errmsg->" + package.validMsg + " &  Errcode->" + package.responseStatus );
  103.                     onShowNetError(package.responseStatus, mId, subId);
  104.  
  105.                     return;
  106.                 }
  107.  
  108.                 if (pb == null)
  109.                 {
  110.                     Debug.Log("收到未在 ProtoMaps 注册的 网络消息  " + package.cmdCode);
  111.                     return;
  112.                 }
  113.  
  114.  
  115.                 if (PackageProtocol.getCmd(package.cmdMerge) == 0)
  116.                 {
  117.                     Debug.Log("心跳数据  ");
  118.                     return;
  119.                 }
  120.  
  121.                 ResponseHandler(package);
  122.                 PushHandler(package);
  123.  
  124.                 //if (pb.typ == 1)
  125.                 //{
  126.                 //}
  127.                 //else if (pb.typ == 2)
  128.                 //{
  129.                 //    PushHandler(package);
  130.                 //}
  131.                 //else
  132.                 //{
  133.                 //    if (!ResponseHandler(package))
  134.                 //        PushHandler(package);
  135.                 //}
  136.  
  137.  
  138.                 //Package package = PackageProtocol.Decode(bytes);
  139.                 //Debug.Log(package.packageType);
  140.                 //switch ((PackageType)package.packageType)
  141.                 //{
  142.                 //    case PackageType.HEARTBEAT:
  143.                 //        //Debug.LogWarning("get HEARTBEAT");
  144.                 //        heartBeatServiceGo.HitHole();
  145.                 //        break;
  146.                 //    case PackageType.RESPONSE:
  147.                 //        ResponseHandler(package);
  148.                 //        break;
  149.                 //    case PackageType.PUSH:
  150.                 //        PushHandler(package);
  151.                 //        break;
  152.                 //    case PackageType.HANDSHAKE:
  153.                 //        HandshakeHandler(package);
  154.                 //        break;
  155.                 //    case PackageType.KICK:
  156.                 //        //HandleKick(package);
  157.                 //        break;
  158.                 //    case PackageType.ERROR:
  159.                 //        ErrorHandler(package);
  160.                 //        break;
  161.                 //    default:
  162.                 //        Debug.Log("No match packageType::" + package.packageType);
  163.                 //        break;
  164.                 //}
  165.             }
  166.             catch (Exception e)
  167.             {
  168.                 ExternalMessage package = PackageProtocol.Decode(bytes);
  169.                 Proto pb = ProtoMaps.Instance.GetByMergeId(package.cmdMerge);
  170.                 Debug.Log("错误协议-----" + JsonUtility.ToJson(pb));
  171.                 await UniTask.SwitchToMainThread();
  172.                 Debug.LogError(e);
  173.                 throw e;
  174.             }
  175.         }
  176.  
  177.         public void StopHeartbeat()
  178.         {
  179.             if (heartBeatServiceGo != null)
  180.             {
  181.                 Debug.Log("Stop Heartbeat");
  182.                 heartBeatServiceGo.Stop();
  183.                 //heartBeatServiceGo = null;
  184.             }
  185.         }
  186.  
  187.         public void onShowNetError(int responseStatus,uint mid,uint subid) {
  188.             
  189.            
  190.  
  191.         }
  192.         public void SetOnNet(uint route, Action<ExternalMessage> ac)
  193.         {
  194.             lock (packAction)
  195.             {
  196.                 if (!packAction.ContainsKey(route))
  197.                 {
  198.                     packAction.Add(route, ac);
  199.                 }
  200.             }
  201.         }
  202.  
  203.         private void PushHandler(ExternalMessage pack)
  204.         {
  205.             lock (packAction)
  206.             {
  207.                 uint route = pack.cmdMerge;
  208.                 if (packAction.ContainsKey(route))
  209.                 {
  210. #if SOCKET_DEBUG
  211.                     Debug.Log(string.Format("[Push] <<-- [{0}] {1}", pack.route, JsonUtility.ToJson(pack)));
  212. #endif
  213.                     packAction[route]?.Invoke(pack);
  214.                     //packAction.Remove(route); //监听事件不考虑删除由netmanager代理
  215.                 }
  216.             }
  217.         }
  218.  
  219.         private bool ResponseHandler(ExternalMessage package)
  220.         {
  221.             lock (packTcs)
  222.             {
  223.                 uint msgId = (uint)package.msgId;
  224.                 //Debug.LogError("响应消息id" + msgId);
  225.                 if (packTcs.ContainsKey(msgId))
  226.                 {
  227.                     packTcs[msgId].TrySetResult(package);
  228.                     packTcs.Remove(msgId);
  229.                     return true;
  230.                     //if (packTcs.ContainsKey(package.cmdMerge))
  231.                     //{
  232.                     //    packTcs.Remove(package.cmdMerge);
  233.                     //    return true;
  234.                     //}
  235.                 }
  236.  
  237.             }
  238.             return false;
  239.         }
  240.  
  241.         //private void ResponseHandler(ExternalMessage package)
  242.         //{
  243.         //    lock (packTcs)
  244.         //    {
  245.         //        packTcs[package.packID].TrySetResult(package);
  246.         //        if (packTcs.ContainsKey(package.packID))
  247.         //        {
  248.         //            packTcs.Remove(package.packID);
  249.         //        }
  250.         //    }
  251.         //}
  252.  
  253.  
  254.         private void HandshakeHandler(Package package)
  255.         {
  256.             Heartbeat msg = PackageProtocol.DecodeInfo<Heartbeat>(package.buff);
  257.             if (msg.heartbeat > 0)
  258.             {
  259.                 handshakeTcs.TrySetResult(false);
  260.                 return;
  261.             }
  262.  
  263.             if (heartBeatServiceGo == null)
  264.             {
  265.  
  266.             }
  267.             else
  268.             {
  269.                 OnReconected?.Invoke();
  270.                 heartBeatServiceGo.ResetTimeout(msg.heartbeat);
  271.             }//*/
  272.             handshakeTcs.TrySetResult(true);
  273.         }
  274.  
  275.         private void ErrorHandler(Package package)
  276.         {
  277.  
  278.         }
  279.  
  280.         private void OnServerTimeout()
  281.         {
  282.             if (socket.ReadyState == WebSocketState.Connecting)
  283.             {
  284.                 socket.CloseAsync();
  285.             }
  286.             if (heartBeatServiceGo != null && socket.ReadyState != WebSocketState.Connecting && socket.ReadyState != WebSocketState.Open)
  287.             {
  288.                 heartBeatServiceGo.Stop();
  289.             }
  290.         }
  291.     }
  292. }

8.定义服务器对应的协议消息：TestProto.cs

  1.  
  2. using ProtoBuf;
  3. using ProtoBuf.Meta;
  4. using System.Collections.Generic;
  5.  
  6. [ProtoContract]
  7. public class RegisterInfo
  8. {
  9.     [ProtoMember(1)]
  10.     public string phoneNum;
  11.     [ProtoMember(2)]
  12.     public string account;
  13.     [ProtoMember(3)]
  14.     public string pwd;
  15. }
  16.  
  17.  
  18. [ProtoContract]
  19. public class LoginVerify 
  20. {
  21.    
  22.     [ProtoMember(1)]
  23.     public string account;
  24.     [ProtoMember(2)]
  25.     public string pwd;
  26.     [ProtoMember(3, DataFormat = DataFormat.ZigZag)]
  27.     public int loginBizCode;
  28.     [ProtoMember(4, DataFormat = DataFormat.ZigZag)]
  29.     public int spaceId;
  30. }
  31.  
  32. [ProtoContract]
  33. public class LobbyTalkMsg
  34. {
  35.     [ProtoMember(1, DataFormat = DataFormat.ZigZag)]
  36.     public long id;
  37.     [ProtoMember(2, DataFormat = DataFormat.ZigZag)]
  38.     public long usrId;
  39.     [ProtoMember(3)]
  40.     public string nickName;
  41.     [ProtoMember(4, DataFormat = DataFormat.ZigZag)]
  42.     public int to_usrId;
  43.     [ProtoMember(5)]
  44.     public string msg;
  45.     [ProtoMember(6, DataFormat = DataFormat.ZigZag)]
  46.     public int msg_type;
  47. }
  48.  
  49. [ProtoContract]
  50. public class RequestSuccess
  51. {
  52.     [ProtoMember(1, DataFormat = DataFormat.ZigZag)]
  53.     public int success;
  54.  
  55. }
  56.  
  57. [ProtoContract]
  58. public class GameFrame {
  59.     [ProtoMember(1, DataFormat = DataFormat.ZigZag)]
  60.     public long frameId;
  61.     [ProtoMember(2)]
  62.     public string opc;
  63.     [ProtoMember(3)]
  64.     public string world;
  65.     [ProtoMember(4)]
  66.     public TankLocation location;
  67.  
  68. }
  69.  
  70.  
  71. [ProtoContract]
  72. public class UserInfo {
  73.     [ProtoMember(1, DataFormat = DataFormat.ZigZag)]
  74.     public long id;
  75.     [ProtoMember(2)]
  76.     public  string nickName;
  77.     [ProtoMember(3)]
  78.     public string account;
  79.     [ProtoMember(4)]
  80.     public string gender;
  81.     
  82.     [ProtoMember(5)]
  83.     public string headImgUrl;
  84.  
  85.     [ProtoMember(6, DataFormat = DataFormat.ZigZag)]
  86.     public long avatarId;
  87.  
  88.     [ProtoMember(7)]
  89.     public string avatar;
  90.     [ProtoMember(8)]
  91.     public string hold;
  92.  
  93.     [ProtoMember(9)]
  94.     public string mtk;
  95.     
  96.     [ProtoMember(10)]
  97.     public string ltk;
  98.  
  99.     [ProtoMember(11, DataFormat = DataFormat.ZigZag)]
  100.     public long roomId;
  101.  
  102.  
  103.     [ProtoMember(12, DataFormat = DataFormat.ZigZag)]
  104.     public long team;
  105.  
  106.  
  107.     [ProtoMember(13)]
  108.     public TankLocation tankLocation;
  109.  
  110.     [ProtoMember(14, DataFormat = DataFormat.ZigZag)]
  111.     public int speed;
  112. }
  113.  
  114. [ProtoContract]
  115. public class TankLocation {
  116.     [ProtoMember(1, DataFormat = DataFormat.ZigZag)]
  117.     public  float x;
  118.     [ProtoMember(2, DataFormat = DataFormat.ZigZag)]
  119.     public float y;
  120.     [ProtoMember(3, DataFormat = DataFormat.ZigZag)]
  121.     public float z;
  122.     [ProtoMember(4, DataFormat = DataFormat.ZigZag)]
  123.     public float dx;
  124.     [ProtoMember(5, DataFormat = DataFormat.ZigZag)]
  125.     public float dy;
  126.     [ProtoMember(6, DataFormat = DataFormat.ZigZag)]
  127.     public float dz;
  128.     [ProtoMember(7, DataFormat = DataFormat.ZigZag)]
  129.     public long playerId;
  130.     [ProtoMember(8, DataFormat = DataFormat.ZigZag)]
  131.     public long time;
  132.  
  133. }
  134.  
  135.  
  136. [ProtoContract]
  137. public class TankPlayer {
  138.     [ProtoMember(1, DataFormat = DataFormat.ZigZag)]
  139.     public long id;
  140.     [ProtoMember(2, DataFormat = DataFormat.ZigZag)]
  141.     public int speed;
  142.     [ProtoMember(3)]
  143.     public TankLocation tankLocation;
  144.     [ProtoMember(4)]
  145.     public string nickname;
  146.     [ProtoMember(5)]
  147.     public string hold;
  148.     // 其他属性: key: 子弹 id 1 玩具弹, 2 雪弹; value : 数量
  149.     [ProtoMember(6)]
  150.     public Dictionary<int, int> tankBulletMap;
  151. }
  152.  
  153.  
  154. [ProtoContract]
  155. public class TankEnterRoom {
  156.     [ProtoMember(1, DataFormat = DataFormat.ZigZag)]
  157.     public long roomId;
  158.     [ProtoMember(2, DataFormat = DataFormat.ZigZag)]
  159.     public long time;
  160.     [ProtoMember(3, DataFormat = DataFormat.ZigZag)]
  161.     public long team;
  162.     [ProtoMember(4, DataFormat = DataFormat.ZigZag)]
  163.     public long playerId;
  164.  
  165.     [ProtoMember(5)]
  166.     public string sharetoken;
  167.  
  168.     [ProtoMember(6)]
  169.     public string usertoken;
  170.  
  171.     [ProtoMember(7)]
  172.     public string world;
  173.  
  174.     [ProtoMember(8)]
  175.     public List<UserInfo> tankPlayerList;
  176.  
  177. }
  178.  
  179. [ProtoContract]
  180. public class UserIds {
  181.     [ProtoMember(1, DataFormat = DataFormat.ZigZag)]
  182.     public long[] userIds;
  183. }
  184.  
  185. [ProtoContract]
  186. public class UserInfos
  187. {
  188.     [ProtoMember(1, DataFormat = DataFormat.ZigZag)]
  189.     public UserInfo[] users;
  190. }
  191.  
  192. [ProtoContract]
  193. public class HeartBeat
  194. {
  195.     [ProtoMember(1, DataFormat = DataFormat.ZigZag)]
  196.     public int beat;
  197. }
  198.  
  199.  
  200.  
  201.

9.定义客户端处理消息类：Client：

  1. using System;
  2. using UnityEngine;
  3. using Cysharp.Threading.Tasks;
  4. using System.Threading;
  5. using System.Collections;
  6. using UnityWebSocket;
  7.  
  8. namespace UTNET
  9. {
  10.     public enum NetWorkState
  11.     {
  12.         CONNECTING,
  13.         CONNECTED,
  14.         DISCONNECTED,
  15.         TIMEOUT,
  16.         ERROR,
  17.         KICK
  18.     }
  19.  
  20.     public class Client
  21.     {
  22.         private static int RqID = 0;
  23.  
  24.         //public NetWorkState state;
  25.  
  26.         public Action OnReconected, OnDisconnect, OnConnected;
  27.         public Action<string> OnError;
  28.         public uint retry;
  29.         public bool isConnect = false;
  30.         Protocol protocol;
  31.         WebSocket socket;
  32.         UniTaskCompletionSource<bool> utcs;
  33.         private bool isForce;
  34.         private bool isHeardbeat = false;
  35.         private string host;
  36.  
  37.         public Client(string host)
  38.         {
  39.             Debug.Log("Client" + host);
  40.             this.host = host;
  41.             this.createSocket();
  42.         }
  43.  
  44.         private void createSocket()
  45.         {
  46.             if (socket != null) {
  47.  
  48.             }
  49.             Debug.Log("createSocket host=" + this.host);
  50.             utcs = new UniTaskCompletionSource<bool>();
  51.             if (socket != null) {
  52.                 socket.CloseAsync();
  53.                 socket.OnClose += ReCreateSocket;
  54.             }
  55.             else {
  56.                 socket = new WebSocket(this.host);
  57.                 socket.OnOpen += OnOpen;
  58.                 socket.OnMessage += OnMessage;
  59.                 socket.OnClose += OnClose;
  60.                 socket.OnError += OnErr;
  61.             }
  62.             
  63.  
  64.            
  65.         }
  66.  
  67.         private void ReCreateSocket(object sender, CloseEventArgs e) {
  68.             socket = new WebSocket(this.host);
  69.             socket.OnOpen += OnOpen;
  70.             socket.OnMessage += OnMessage;
  71.             socket.OnClose += OnClose;
  72.             socket.OnError += OnErr;
  73.         }
  74.  
  75.         //断线重连逻辑
  76.         public IEnumerator ReconectScoektAsync()
  77.         {
  78.             while (true)
  79.             {
  80.                 yield return new WaitForSeconds(2);
  81.                 Debug.Log(" client : reconectScoekt");
  82.                 if (socket.ReadyState == WebSocketState.Connecting || socket.ReadyState == WebSocketState.Open) break;
  83.                 socket.ConnectAsync();
  84.             }
  85.         }
  86.  
  87.  
  88.         //开始心跳逻辑
  89.         public IEnumerator StartHeardBeat()
  90.         {
  91.             isHeardbeat = true;
  92.             while (true)
  93.             {
  94.                 Debug.Log("开始发送心跳");
  95.                 if (isHeardbeat == false) continue;
  96.                 yield return new WaitForSeconds(2);
  97.                 //发送心跳
  98.                 this.sendHeardbeat();
  99.             }
  100.         }
  101.  
  102.         private async void sendHeardbeat()
  103.         {
  104.             int u1 = await this.RequestAsync<int, int>("heartbeat", 21);
  105.  
  106.         }
  107.  
  108.  
  109.         public UniTask<bool> ConnectAsync()
  110.         {
  111.             socket.ConnectAsync();
  112.             return utcs.Task;
  113.         }
  114.  
  115.         private void OnOpen(object sender, OpenEventArgs e)
  116.         {
  117.             if (protocol == null)
  118.                 protocol = new Protocol();
  119.             protocol.SetSocket(socket);
  120.             protocol.OnReconected = OnReconected;
  121.             protocol.OnError = OnError;
  122.             //bool isOK = await protocol.HandsharkAsync(this.token);
  123.             Debug.Log("open:" + e);
  124.             isConnect = true;
  125.             utcs.TrySetResult(true);
  126.             OnConnected?.Invoke();
  127.         }
  128.  
  129.  
  130.         private async void OnClose(object sender, CloseEventArgs e)
  131.         {
  132.             if (socket.ReadyState == UnityWebSocket.WebSocketState.Connecting || socket.ReadyState == UnityWebSocket.WebSocketState.Open) return;
  133.             await UniTask.SwitchToMainThread();
  134.             isConnect = false;
  135.             Cancel();
  136.             if (!isForce)
  137.             {
  138.                 await UniTask.Delay(1000);
  139.                 //socket.Open();
  140.             }
  141.             OnDisconnect?.Invoke();
  142.         }
  143.  
  144.         public void OnErr(object sender, ErrorEventArgs e)
  145.         {
  146.             utcs.TrySetResult(false);
  147.             isConnect = false;
  148.             //Debug.LogError(e.Exception.Message);
  149.         }
  150.  
  151.         private void OnMessage(object sender, MessageEventArgs e)
  152.         {
  153.             protocol.OnReceive(e.RawData);
  154.             isConnect = true;
  155.         }
  156.  
  157.  
  158.         public void OnNet(uint mid, uint sid, Action<ExternalMessage> cb)
  159.         {
  160.             uint merge = PackageProtocol.getMergeCmd(mid, sid);
  161.             protocol.SetOnNet(merge, cb);
  162.         }
  163.  
  164.         public void OnNetEx(string name, Action<ExternalMessage> cb)
  165.         {
  166.             Proto pb = ProtoMaps.Instance.protos[name] as Proto;
  167.             uint merge = PackageProtocol.getMergeCmd(pb.mid, pb.sid);
  168.             protocol.SetOnNet(merge, cb);
  169.         }
  170.  
  171.         public void Notify<T>(string route, T info = default)
  172.         {
  173.             //uint rqID = (uint)Interlocked.Increment(ref RqID);
  174.             try
  175.             {
  176. #if SOCKET_DEBUG
  177.                 Debug.Log(string.Format("[Notify] -->> [{0}] {1}", route, JsonUtility.ToJson(info)));
  178. #endif
  179.                 protocol.Notify<T>(route, info);
  180.             }
  181.             catch (Exception e)
  182.             {
  183.                 Debug.Log(string.Format("[Notify Exception]{0}", e.Message));
  184.                 throw e;
  185.             }
  186.         }
  187.  
  188.  
  189.  
  190.         public async UniTask<S> RequestAsyncEx<T, S>(uint mid, uint sid, T info = default, string modelName = null)
  191.         {
  192.  
  193.             uint cmdMerge = PackageProtocol.getMergeCmd(mid, sid);
  194.  
  195.             uint rqID = (uint)Interlocked.Increment(ref RqID);
  196.             try
  197.             {
  198. #if SOCKET_DEBUG
  199.                 Debug.Log(string.Format("[{0}][Request] -->> [{1}] {2}", rqID, route, JsonUtility.ToJson(info)));
  200. #endif
  201.  
  202.                 ExternalMessage pack = await protocol.RequestAsync<T>(rqID, cmdMerge, info, modelName);
  203.  
  204.                 S msg = PackageProtocol.DecodeInfo<S>(pack.data);
  205.  
  206.  
  207. #if SOCKET_DEBUG
  208.                 Debug.Log(string.Format("[{0}][Request] <<-- [{1}] {2} {3}", rqID, route, JsonUtility.ToJson(msg), JsonUtility.ToJson(msg.info)));
  209. #endif
  210.                 return msg;
  211.             }
  212.             catch (Exception e)
  213.             {
  214.                 //Debug.Log(string.Format("[{0}][RequestAsync Exception]{1}", rqID, e.Message));
  215.                 throw e;
  216.             }
  217.         }
  218.  
  219.  
  220.         public async UniTask<S> RequestAsync<T, S>(string name, T info = default, string modelName = null)
  221.         {
  222.             
  223.             // #if UNITY_WEBGL && !UNITY_EDITOR  //只在WebGl下生效
  224.             if (PlayerData.Instance.IsEditorMode) {
  225.                 S msg = PackageProtocol.DecodeInfo<S>(null);
  226.                 return msg;
  227.             }
  228.             //#endif
  229.  
  230.             //Debug.Log($"sendMsg {name}");
  231.  
  232.             Proto pb = ProtoMaps.Instance.Name2Pb(name);
  233.  
  234.                 uint cmdMerge = PackageProtocol.getMergeCmd(pb.mid, pb.sid);
  235.  
  236.                 uint rqID = (uint)Interlocked.Increment(ref RqID);
  237.                 //Debug.LogError("调试消息id" + rqID);
  238.  
  239.                 try
  240.                 {
  241. #if SOCKET_DEBUG
  242.                 Debug.Log(string.Format("[{0}][Request] -->> [{1}] {2}", rqID, route, JsonUtility.ToJson(info)));
  243. #endif
  244.  
  245.                     ExternalMessage pack = await protocol.RequestAsync<T>(rqID, cmdMerge, info, modelName);
  246.  
  247.  
  248.                     S msg = PackageProtocol.DecodeInfo<S>(pack.data);
  249. #if SOCKET_DEBUG
  250.                 Debug.Log(string.Format("[{0}][Request] <<-- [{1}] {2} {3}", rqID, route, JsonUtility.ToJson(msg), JsonUtility.ToJson(msg.info)));
  251. #endif
  252.                     return msg;
  253.                 }
  254.                 catch (Exception e)
  255.                 {
  256.                     //Debug.Log(string.Format("[{0}][RequestAsync Exception]{1}", rqID, e.Message));
  257.                     //Debug.Log("房间网络连接断开.......");
  258.                     S msg = PackageProtocol.DecodeInfo<S>(null);
  259.                     return msg;
  260.                     throw e;
  261.                 }
  262.  
  263.             
  264.  
  265.             
  266.         }
  267.  
  268.         public void Cancel(bool isForce = false)
  269.         {
  270.             this.isForce = isForce;
  271.             utcs.TrySetCanceled();
  272.             if (socket.ReadyState != UnityWebSocket.WebSocketState.Closed)
  273.             {
  274.                 socket.CloseAsync();
  275.             }
  276.             if (protocol != null)
  277.             {
  278.                 protocol.StopHeartbeat();
  279.                 protocol.CanceledAllUTcs();
  280.             }
  281.         }
  282.  
  283.  
  284.         public UnityWebSocket.WebSocketState getSocketState() {
  285.  
  286.             if (socket != null) {
  287.  
  288.                 return socket.ReadyState;
  289.             }
  290.             return 0;
  291.         }
  292.  
  293.  
  294.         public void Close() {
  295.             Debug.Log("UnityWebSocket......" + socket);
  296.             Debug.Log("UnityWebSocket状态......"+ socket.ReadyState);
  297.             if (socket!=null && socket.ReadyState == UnityWebSocket.WebSocketState.Open) {
  298.                 socket.CloseAsync();
  299.                 Debug.Log("强制玩家关闭连接......");
  300.             }
  301.         }
  302.  
  303.  
  304.         void OnDestroy()
  305.         {
  306.             socket.CloseAsync(); 
  307.         }
  308.     }
  309. }

10.最终定义网络管理器：NetManager.cs

  1.  
  2. using Cysharp.Threading.Tasks;
  3. using System;
  4. using System.Collections.Generic;
  5. using System.IO;
  6. using UnityEngine;
  7. using UnityEngine.Networking;
  8. using UTNET;
  9.  
  10.  
  11. public class NetMessage<T> {
  12.     public uint mergeid;
  13.     delegate void Message(object sender, T msg);
  14.  
  15. }
  16.  
  17. public class NetManager : MonoBehaviour {
  18.  
  19.     private NetManager() { }
  20.  
  21.     public static NetManager Instance;
  22.  
  23.  
  24.     public string token, version;
  25.     public Client client;
  26.     public bool isConeccet = false;
  27.     public string HaiMetaSpaceUrl = "*****";
  28.  
  29.     //192.144.138.221  /game.icewhale.net
  30.     Dictionary<string, List<Action<ExternalMessage>>> actions = new Dictionary<string, List<Action<ExternalMessage>>>();
  31.     private Coroutine rec;
  32.  
  33.  
  34.  
  35.     private void Awake() {
  36.         Instance = this;
  37.     }
  38.  
  39.     async void Start() {
  40.         DontDestroyOnLoad(this);
  41.         Screen.sleepTimeout = SleepTimeout.NeverSleep;
  42.         pushBtn();
  43.     }
  44.  
  45.     //public Client getNewClient() {
  46.  
  47.     //    return newClient;
  48.     //}
  49.  
  50.     //public void setNewClient(Client vNewClient) {
  51.  
  52.     //    newClient = vNewClient;
  53.     //}
  54.  
  55.  
  56.     public void webOpenHaiMetaUrl(string param = null) {
  57.  
  58.         //string url = this.HaiMetaSpaceUrl+param;
  59.         //UnityEngine.Application.ExternalEval("window.location.href = \"" + url + "\";");
  60.     }
  61.  
  62.     public void webOpenNewSpace(string spaceUrl,string spaceId)
  63.     {
  64.  
  65.         string url = spaceUrl + "?param={\"spaceId\":"+ spaceId + ",\"userName\":"+PlayerData.Instance.Name+",\"templateId\":"+ PlayerData.Instance.TemplateId + "}" + "&token=" + PlayerData.Instance.ltk + "&type=4"+ "&state=1";
  66.         UnityEngine.Application.ExternalEval("window.location.href = \"" + url + "\";");
  67.  
  68.  
  69.     }
  70.  
  71.     private void Update() {
  72.         //if (client == null && newClient != null) {
  73.  
  74.         //    client = getNewClient();
  75.         //}
  76.     }
  77.  
  78.     public async void CreateConeccetionBtn()
  79.     {
  80.  
  81.         //string host = string.Format("wss://*****");
  82.         Debug.Log("CreateConeccetionBtn" +Host.gameServer);
  83.         client = new Client(Host.gameServer);
  84.         client.OnDisconnect = OnDisconnect;
  85.         client.OnReconected = OnReconected;
  86.         client.OnError = OnError;
  87.         client.OnConnected = OnConnected;
  88.  
  89.         bool isConeccet = await client.ConnectAsync();
  90.         if (isConeccet)
  91.         {
  92.             Debug.Log("网络链接成功");
  93.         }
  94.  
  95.     }
  96.  
  97.     //public void resetClient() {
  98.     //    setNewClient(client);
  99.     //}
  100.  
  101.     private void OnConnected() {
  102.         Debug.Log("OnConnected");
  103.         if (rec != null)
  104.             StopCoroutine(rec);
  105.         this.TriggerEvent(EventName.SocketOpen, null);
  106.  
  107.     }
  108.  
  109.  
  110.  
  111.  
  112.  
  113.     private void OnError(string msg) {
  114.         Debug.LogError(string.Format("err msg:{0}", msg));
  115.     }
  116.  
  117.     private void OnReconected() {
  118.         Debug.Log("OnReconect");
  119.     }
  120.  
  121.     private void OnDisconnect() {
  122.         Debug.Log("OnDisconnect");
  123.         //client = null;
  124.         rec = StartCoroutine(client.ReconectScoektAsync()); //断线重连逻辑
  125.     }
  126.  
  127.     public void pushBtn() {
  128.         LoadNetCofig();
  129.     }
  130.  
  131.     void LoadNetCofig() {
  132.         var configPath = Application.dataPath;
  133.  
  134. #if UNITY_EDITOR
  135.         var filepath = Path.Combine(Application.dataPath.Replace("Assets", ""), "config.txt");
  136. #else
  137.         var filepath = Path.Combine(Application.dataPath, "config.txt");
  138. #endif
  139.         Debug.Log("configPath" + filepath);
  140.         filepath = filepath.Replace("\\", "/");
  141.        LoadFileSetNetwork(filepath);
  142.     }
  143.  
  144.  
  145.  
  146.     async void LoadFileSetNetwork(string filepath) {
  147.         UnityWebRequest www = UnityWebRequest.Get(filepath);
  148.  
  149.  
  150.         await www.SendWebRequest();
  151.  
  152.         if (www.result == UnityWebRequest.Result.ConnectionError || www.result == UnityWebRequest.Result.ProtocolError) {
  153.             Debug.LogError(www.error);
  154.         }
  155.         else {
  156.             string json = www.downloadHandler.text;
  157.             var data = LitJson.JsonMapper.ToObject(json);
  158.  
  159.             if ((string)data["AssetBundleIP"] != string.Empty) {
  160.                 Host.AssetBundleIP = (string)data["AssetBundleIP"];
  161.             }
  162. #if UNITY_EDITOR
  163.             var serverMode = AppConst.serverMode;
  164. #else
  165.             var serverMode  = (ServerMode)int.Parse(HttpHelper.GetUrlParam("severAPI"));
  166. #endif
  167.             AppConst.serverMode = serverMode;
  168.             switch (serverMode) {
  169.                 case ServerMode.preview:
  170.                     Host.ApiHost = (string)data["preview"];
  171.                     break;
  172.                 case ServerMode.dev:
  173.                     Host.ApiHost = (string)data["dev"];
  174.                     break;
  175.             }
  176.  
  177.  
  178.  
  179.  
  180. #if !UNITY_EDITOR
  181.             var paramUrl = HttpHelper.GetUrlParam("param");
  182.             JsonData paramdata = JsonMapper.ToObject(UtilsFunc.UnicodeToString(paramUrl));
  183.             try {
  184.                 string spaceId = paramdata["spaceId"].ToJson();
  185.                 PlayerData.Instance.SpaceId = spaceId;
  186.                 PlayerData.Instance.ltk = HttpHelper.GetUrlParam("token");
  187.               
  188.               
  189.             }
  190.             catch (Exception e) {
  191.                 Debug.LogError(e.Message + '\n' + e.StackTrace);
  192.             }
  193. #endif
  194.             Debug.Log("LoadFileSetNetwork SpaceId" + PlayerData.Instance.SpaceId);
  195.  
  196.             //如果在编辑器下面，并且不填sapceId,那么则进入发布模式
  197.  
  198.             if (string.IsNullOrEmpty(PlayerData.Instance.SpaceId) == false) {
  199.                 await HttpHelper.Instance.GetSceneConfig();
  200.             }
  201.  
  202.  
  203. #if !UNITY_EDITOR
  204.             if (paramdata.ContainsKey("templateId")) {
  205.  
  206.                 if (paramdata["templateId"] != null) {
  207.                     string tempStr = (string)paramdata["templateId"];
  208.                     bool isExist = int.TryParse(tempStr,out var tempId);
  209.                     if (isExist) PlayerData.Instance.TemplateId = tempId;
  210.                 }
  211.                     
  212.             }
  213.  
  214.             string stateUrl = HttpHelper.GetUrlParam("state");
  215. #else
  216.             string stateUrl = string.IsNullOrEmpty(PlayerData.Instance.SpaceId) == true ? AppConst.PublicMode : AppConst.ViewMode;
  217. #endif
  218.             var arg = new SceneLoadActionArgs();
  219.             arg.state = stateUrl;
  220.  
  221.  
  222.             
  223.  
  224.  
  225.             EventManager.Instance.TriggerEvent(EventName.LoadSceneAction, arg);
  226.  
  227.             if (stateUrl == AppConst.PublicMode) {
  228.                 PlayerData.Instance.IsEditorMode = true;
  229.                 PlayerData.Instance.IsPublicMode = true;
  230.                 EventManager.Instance.TriggerEvent(EventName.OnPublishEnter);
  231.                 HttpHelper.Instance.GetDefaultSpaceImg();
  232.                 return;
  233.             }
  234.  
  235. #if !UNITY_EDITOR
  236.             await HttpHelper.Instance.GetServerConfig();
  237. #else
  238.             Host.gameServer = (string)data["local"];
  239. #endif
  240.             CreateConeccetionBtn();
  241.  
  242.         }
  243.     }
  244.  
  245.     private async UniTaskVoid CreateConeccetion() {
  246.         Debug.Log("开始...");
  247.  
  248.         bool isConeccet  = await client.ConnectAsync();
  249.  
  250.         if (isConeccet) {
  251.             Debug.Log("网络链接成功");
  252.             // this.Register<RegisterInfo>("test", (int code) =>
  253.             // {
  254.             //     Debug.Log("网络事件" +code);
  255.             // });
  256.             if (client != null) client.isConnect = true;
  257.  
  258.             //this.SendAPI();
  259.  
  260.         }
  261.         else
  262.             Debug.Log("多次链接仍让未成功");
  263.     }
  264.  
  265.     public void AddSyncHandler(string name, Action<SyncWrapData> call) {
  266.         NetManager.Instance.Register<GameFrame>("gameFrame", (ExternalMessage pack) => {
  267.             GameFrame info = PackageProtocol.DecodeInfo<GameFrame>(pack.data);
  268.             //if (info.location.playerId == PlayerData.Instance.PlayerId) {
  269.             //    return; //自己不用给自己同步
  270.             //}
  271.  
  272.             var opc = info.opc;
  273.             SyncWrapData dataBase = null;
  274.             try {
  275.  
  276.                 dataBase = JsonUtility.FromJson<SyncWrapData>(opc);
  277.  
  278.                 if (dataBase.playerId != PlayerData.Instance.PlayerId.ToString()) { //只接受不同playerId的数据
  279.                     call.Invoke(dataBase);
  280.                 }
  281.  
  282.             }
  283.             catch (Exception e) {
  284.                 //Debug.LogError(e);
  285.             }
  286.         });
  287.     }
  288.  
  289.     public async void SendSyncData(SyncWrapData syncBase) {
  290.         string jsonData = JsonUtility.ToJson(syncBase);
  291.  
  292.         if (NetManager.Instance.client == null) {
  293.             Debug.LogError("NetManager.Instance.client == null");
  294.             return;
  295.         }
  296.  
  297.         var gameFrame = new GameFrame();
  298.         gameFrame.opc = jsonData;
  299.         await NetManager.Instance.client.RequestAsync<GameFrame, GameFrame>("gameFrame", gameFrame);
  300.     }
  301.  
  302.     public async void SendSyncWorldData(SyncWorldData worldData) {
  303.         string jsonData = LitJson.JsonMapper.ToJson(worldData);
  304.  
  305.         if (NetManager.Instance.client == null) {
  306.             Debug.LogError("NetManager.Instance.client == null");
  307.             return;
  308.         }
  309.         //Debug.Log("SendSyncWorldData worldData:" + jsonData);
  310.         var gameFrame = new GameFrame();
  311.         gameFrame.world = jsonData;
  312.         await NetManager.Instance.client.RequestAsync<GameFrame, GameFrame>("gameFrame", gameFrame);
  313.     }
  314.  
  315.     public async void SendFrameLocationData(SyncTransfomData syncPos,SyncWrapData wrap) {
  316.  
  317.         if (NetManager.Instance.client == null) {
  318.             Debug.LogError("NetManager.Instance.client == null");
  319.             return;
  320.         }
  321.  
  322.         var gameFrame = new GameFrame();
  323.  
  324.         gameFrame.opc = JsonUtility.ToJson(wrap);
  325.  
  326.         gameFrame.location = new TankLocation();
  327.         SyncTransfomUtil.ToTankLocation(ref gameFrame.location, syncPos);
  328.         gameFrame.location.playerId = PlayerData.Instance.PlayerId;
  329.  
  330.         await NetManager.Instance.client.RequestAsync<GameFrame, GameFrame>("gameFrame", gameFrame);
  331.     }
  332.  
  333.  
  334.  
  335.  
  336.     public void Register<T>(string name, Action<ExternalMessage> ac) {
  337.         //#if UNITY_WEBGL && !UNITY_EDITOR  //只在WebGl下生效
  338.         if (PlayerData.Instance.IsEditorMode) return;
  339.         //#endif
  340.         //加入事件列表
  341.         Proto pb = ProtoMaps.Instance.Name2Pb(name);
  342.  
  343.         List<Action<ExternalMessage>> list = null;
  344.         if (actions.ContainsKey(name)) {
  345.             list = actions[name];
  346.         }
  347.         else {
  348.             list = new List<Action<ExternalMessage>>();
  349.             actions.Add(name, list);
  350.         }
  351.         list.Add(ac);
  352.  
  353.         client.OnNetEx(name, (ExternalMessage pack) => {
  354.             T info = PackageProtocol.DecodeInfo<T>(pack.data);
  355.             //Debug.Log("网络事件" + JsonUtility.ToJson(info));
  356.             //遍历事件列表依次回调
  357.             foreach (Action<ExternalMessage> cb in list) {
  358.                 cb?.Invoke(pack);
  359.             }
  360.  
  361.         });
  362.  
  363.     }
  364.  
  365.  
  366.     public async void SendAPI() {
  367.  
  368.         //请求注册
  369.         //RegisterInfo register = new RegisterInfo();
  370.         //register.account = "abc";
  371.         //register.phoneNum = "abc";
  372.         //register.pwd = "abc";
  373.  
  374.         //RegisterInfo a = await client.RequestAsync<RegisterInfo, RegisterInfo>("test", register);
  375.  
  376.         //Debug.Log(a.phoneNum);
  377.  
  378.  
  379.         client.OnNetEx("login", (ExternalMessage pack) => {
  380.  
  381.             Debug.LogError("回调返回");
  382.             //T info = PackageProtocol.DecodeInfo<T>(pack.data);
  383.             Debug.Log("网络事件" + JsonUtility.ToJson(info));
  384.             遍历事件列表依次回调
  385.             //foreach (Action<ExternalMessage> cb in list)
  386.             //{
  387.             //    cb?.Invoke(pack);
  388.             //}
  389.  
  390.         });
  391.  
  392.  
  393.  
  394.         LoginVerify loginVerify = new LoginVerify();
  395.         loginVerify.account = "18060974935";
  396.         loginVerify.pwd = "123456ab";
  397.         loginVerify.loginBizCode = 1;
  398.  
  399.         UserInfo ret = await NetManager.Instance.client.RequestAsync<LoginVerify, UserInfo>("login", loginVerify);
  400.         Debug.Log(ret.nickName);
  401.  
  402.  
  403.         TankEnterRoom myEnterRoom = new TankEnterRoom();
  404.  
  405.         myEnterRoom.roomId = 1002;
  406.         myEnterRoom.team = 1;
  407.  
  408.         TankEnterRoom ret2 = await NetManager.Instance.client.RequestAsync<TankEnterRoom, TankEnterRoom>("enterRoom", myEnterRoom);
  409.         Debug.Log(ret2.time);
  410.  
  411.  
  412.  
  413.  
  414.         //int code = await client.RequestAsync<String, int>("gameObjUsed", "ok");
  415.  
  416.  
  417.     }
  418.  
  419.     public bool isConnected() {
  420.         return isConeccet;
  421.     }
  422.  
  423.     private void OnDestroy() {
  424.         if (client != null) {
  425.             client.Cancel();
  426.         }
  427.     }
  428. }
  429.

11.发送网络消息的应用：

UserInfo ret = await NetManager.Instance.client.RequestAsync<LoginVerify, UserInfo>("login", loginVer);

12.监听网络消息：

  1. NetManager.Instance.Register<TankEnterRoom>("enterRoom", (ExternalMessage pack) =>
  2. {
  3.     Debug.Log("新玩家进去");
  4.     this.onNewRoleEnter2(pack);
  5. });
  1.     public void onNewRoleEnter2(ExternalMessage pack) {
  2.         TankEnterRoom info = PackageProtocol.DecodeInfo<TankEnterRoom>(pack.data);
  3.         List<UserInfo> roleList = info.tankPlayerList;
  4.         Debug.Log("新进入房间玩家列表" + roleList.ToString());
  5.         long roleId = info.playerId;
  6.         Debug.Log("新进入房间玩家id" + roleId);
  7.         foreach (UserInfo vRole in roleList)
  8.         {
  9.             Debug.Log("新进入房间玩家" + JsonUtility.ToJson(vRole));
  10.             if (vRole.id == roleId && vRole.id!=PlayerData.Instance.PlayerId)
  11.             {
  12.                 if (!RolesManager.Instance.isExistRoleById(vRole.id)) {
  13.                     GuestinfoDataModel.Instance.OnNewRoleIntoRoom(vRole);
  14.                     RolesManager.Instance.synPlayer(vRole, true);
  15.                 } 
  16.             }
  17.         }
  18.         
  19.     }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/107323
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号