码迷，mamicode.com
首页 > 编程语言 > 详细

Unity3D 游戏引擎之C#使用Socket与HTTP连接server数据传输包

时间：2017-05-23 14:17:53      阅读：347      评论：0      收藏：0      [点我收藏+]

标签：索引   generic   数组   计算   int   stream   coroutine   cti   多线程   

近期比較忙。有段时间没写博客拉。近期项目中须要使用HTTP与Socket。雨松MOMO把自己这段时间学习的资料整理一下。

有关Socket与HTTP的基础知识MOMO就不赘述拉，不懂得朋友自己谷歌吧。我们项目的需求是在登录的时候使用HTTP请求。游戏中其他的请求都用Socket请求。比方人物移动同步坐标。同步关卡等等。

1.Socket

        Socket不要写在脚本上。假设写在脚本上游戏场景一旦切换，那么这条脚本会被释放掉。Socket会断开连接。

场景切换完成后须要又一次在与server建立Socket连接，这样会非常麻烦。所以我们须要把Socket写在一个单例的类中，不用继承MonoBehaviour。这个样例我模拟一下。主角在游戏中移动，时时向服务端发送当前坐标，当server返回同步坐标时角色開始同步服务端新角色坐标。

Socket在发送消息的时候採用的是字节数组，也就是说不管你的数据是 int float short object 都会将这些数据类型先转换成byte[] 。 眼下在处理发送的地方我使用的是数据包。也就是把（角色坐标）结构体object转换成byte[]发送， 这就牵扯一个问题， 怎样把结构体转成字节数组， 怎样把字节数组回转成结构体。请大家接续阅读。答案就在后面，哇咔咔。

直接上代码

JFSocket.cs 该单例类不要绑定在不论什么对象上

[c#] view plaincopy
  1. using UnityEngine;     
  2. using System.Collections;     
  3. using System;     
  4. using System.Threading;     
  5. using System.Text;     
  6. using System.Net;     
  7. using System.Net.Sockets;     
  8. using System.Collections.Generic;     
  9. using System.IO;     
  10. using System.Runtime.InteropServices;     
  11. using System.Runtime.Serialization;     
  12. using System.Runtime.Serialization.Formatters.Binary;     
  13.          
  14. public class JFSocket     
  15. {     
  16.          
  17.     //Socket客户端对象     
  18.     private Socket clientSocket;     
  19.     //JFPackage.WorldPackage是我封装的结构体。     
  20.     //在与server交互的时候会传递这个结构体     
  21.     //当客户端接到到server返回的数据包时。我把结构体add存在链表中。     
  22.     public List<JFPackage.WorldPackage> worldpackage;     
  23.     //单例模式     
  24.     private static JFSocket instance;     
  25.     public static JFSocket GetInstance()     
  26.     {     
  27.         if (instance == null)     
  28.         {     
  29.             instance = new JFSocket();     
  30.         }     
  31.         return instance;     
  32.      }           
  33.          
  34.     //单例的构造函数     
  35.     JFSocket()     
  36.     {     
  37.         //创建Socket对象， 这里我的连接类型是TCP     
  38.         clientSocket = new Socket (AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);     
  39.         //serverIP地址     
  40.         IPAddress ipAddress = IPAddress.Parse ("192.168.1.100");     
  41.         //serverport     
  42.         IPEndPoint ipEndpoint = new IPEndPoint (ipAddress, 10060);     
  43.         //这是一个异步的建立连接，当连接建立成功时调用connectCallback方法     
  44.         IAsyncResult result = clientSocket.BeginConnect (ipEndpoint,new AsyncCallback (connectCallback),clientSocket);     
  45.         //这里做一个超时的监測，当连接超过5秒还没成功表示超时     
  46.         bool success = result.AsyncWaitHandle.WaitOne( 5000, true );     
  47.         if ( !success )     
  48.         {     
  49.             //超时     
  50.             Closed();     
  51.             Debug.Log("connect Time Out");     
  52.         }else  
  53.         {     
  54.             //与socket建立连接成功，开启线程接受服务端数据。     
  55.             worldpackage = new List<JFPackage.WorldPackage>();     
  56.             Thread thread = new Thread(new ThreadStart(ReceiveSorket));     
  57.             thread.IsBackground = true;     
  58.             thread.Start();     
  59.         }     
  60.     }     
  61.          
  62.     private void connectCallback(IAsyncResult asyncConnect)     
  63.     {     
  64.         Debug.Log("connectSuccess");     
  65.     }     
  66.          
  67.     private void ReceiveSorket()     
  68.     {     
  69.         //在这个线程中接受server返回的数据     
  70.         while (true)     
  71.         {      
  72.          
  73.             if(!clientSocket.Connected)     
  74.             {     
  75.                 //与server断开连接跳出循环     
  76.                 Debug.Log("Failed to clientSocket server.");     
  77.                 clientSocket.Close();     
  78.                 break;     
  79.             }     
  80.             try  
  81.             {     
  82.                 //接受数据保存至bytes其中     
  83.                 byte[] bytes = new byte[4096];     
  84.                 //Receive方法中会一直等待服务端回发消息     
  85.                 //假设没有回发会一直在这里等着。     
  86.                 int i = clientSocket.Receive(bytes);     
  87.                 if(i <= 0)     
  88.                 {     
  89.                     clientSocket.Close();     
  90.                     break;     
  91.                 }        
  92.          
  93.                 //这里条件可依据你的情况来推断。

         

  94.                 //由于我眼下的项目先要监測包头长度，     
  95.                 //我的包头长度是2，所以我这里有一个推断     
  96.                 if(bytes.Length > 2)     
  97.                 {     
  98.                     SplitPackage(bytes,0);     
  99.                 }else  
  100.                 {     
  101.                     Debug.Log("length is not  >  2");     
  102.                 }     
  103.          
  104.              }     
  105.              catch (Exception e)     
  106.              {     
  107.                 Debug.Log("Failed to clientSocket error." + e);     
  108.                 clientSocket.Close();     
  109.                 break;     
  110.              }     
  111.         }     
  112.     }        
  113.          
  114.     private void SplitPackage(byte[] bytes , int index)     
  115.     {     
  116.         //在这里进行拆包。由于一次返回的数据包的数量是不定的     
  117.         //所以须要给数据包进行查分。     
  118.         while(true)     
  119.         {     
  120.             //包头是2个字节     
  121.             byte[] head = new byte[2];     
  122.             int headLengthIndex = index + 2;     
  123.             //把数据包的前两个字节拷贝出来     
  124.             Array.Copy(bytes,index,head,0,2);     
  125.             //计算包头的长度     
  126.             short length = BitConverter.ToInt16(head,0);     
  127.             //当包头的长度大于0 那么须要依次把同样长度的byte数组拷贝出来     
  128.             if(length > 0)     
  129.             {     
  130.                 byte[] data = new byte[length];     
  131.                 //拷贝出这个包的所有字节数     
  132.                 Array.Copy(bytes,headLengthIndex,data,0,length);     
  133.                 //把数据包中的字节数组强制转换成数据包的结构体     
  134.                 //BytesToStruct()方法就是用来转换的     
  135.                 //这里须要和你们的服务端程序商议。     
  136.                 JFPackage.WorldPackage wp = new JFPackage.WorldPackage();     
  137.                 wp = (JFPackage.WorldPackage)BytesToStruct(data,wp.GetType());     
  138.                 //把每一个包的结构体对象加入至链表中。     
  139.                 worldpackage.Add(wp);     
  140.                 //将索引指向下一个包的包头     
  141.                 index  =  headLengthIndex + length;     
  142.          
  143.             }else  
  144.             {     
  145.                 //假设包头为0表示没有包了。那么跳出循环     
  146.     
  147.                 break;     
  148.             }     
  149.         }     
  150.     }        
  151.          
  152.     //向服务端发送一条字符串     
  153.     //一般不会发送字符串 应该是发送数据包     
  154.     public void SendMessage(string str)     
  155.     {     
  156.         byte[] msg = Encoding.UTF8.GetBytes(str);     
  157.          
  158.         if(!clientSocket.Connected)     
  159.         {     
  160.             clientSocket.Close();     
  161.             return;     
  162.         }     
  163.         try  
  164.         {     
  165.             //int i = clientSocket.Send(msg);     
  166.             IAsyncResult asyncSend = clientSocket.BeginSend (msg,0,msg.Length,SocketFlags.None,new AsyncCallback (sendCallback),clientSocket);     
  167.             bool success = asyncSend.AsyncWaitHandle.WaitOne( 5000, true );     
  168.             if ( !success )     
  169.             {     
  170.                 clientSocket.Close();     
  171.                 Debug.Log("Failed to SendMessage server.");     
  172.             }     
  173.         }     
  174.         catch  
  175.         {     
  176.              Debug.Log("send message error" );     
  177.         }     
  178.     }     
  179.          
  180.     //向服务端发送数据包，也就是一个结构体对象     
  181.     public void SendMessage(object obj)     
  182.     {     
  183.          
  184.         if(!clientSocket.Connected)     
  185.         {     
  186.             clientSocket.Close();     
  187.             return;     
  188.         }     
  189.         try  
  190.         {     
  191.             //先得到数据包的长度     
  192.             short size = (short)Marshal.SizeOf(obj);     
  193.             //把数据包的长度写入byte数组中     
  194.             byte [] head = BitConverter.GetBytes(size);     
  195.             //把结构体对象转换成数据包，也就是字节数组     
  196.             byte[] data = StructToBytes(obj);     
  197.          
  198.             //此时就有了两个字节数组。一个是标记数据包的长度字节数组， 一个是数据包字节数组，     
  199.             //同一时候把这两个字节数组合并成一个字节数组     
  200.          
  201.             byte[] newByte = new byte[head.Length + data.Length];     
  202.             Array.Copy(head,0,newByte,0,head.Length);     
  203.             Array.Copy(data,0,newByte,head.Length, data.Length);     
  204.          
  205.             //计算出新的字节数组的长度     
  206.             int length = Marshal.SizeOf(size) + Marshal.SizeOf(obj);     
  207.          
  208.             //向服务端异步发送这个字节数组     
  209.             IAsyncResult asyncSend = clientSocket.BeginSend (newByte,0,length,SocketFlags.None,new AsyncCallback (sendCallback),clientSocket);     
  210.             //监測超时     
  211.             bool success = asyncSend.AsyncWaitHandle.WaitOne( 5000, true );     
  212.             if ( !success )     
  213.             {     
  214.                 clientSocket.Close();     
  215.                 Debug.Log("Time Out !");     
  216.             }      
  217.          
  218.         }     
  219.         catch (Exception e)     
  220.         {     
  221.              Debug.Log("send message error: " + e );     
  222.         }     
  223.     }     
  224.          
  225.     //结构体转字节数组     
  226.     public byte[] StructToBytes(object structObj)     
  227.     {     
  228.          
  229.         int size = Marshal.SizeOf(structObj);     
  230.         IntPtr buffer =  Marshal.AllocHGlobal(size);     
  231.         try  
  232.         {     
  233.             Marshal.StructureToPtr(structObj,buffer,false);     
  234.             byte[]  bytes  =   new byte[size];     
  235.             Marshal.Copy(buffer, bytes,0,size);     
  236.             return   bytes;     
  237.         }     
  238.         finally  
  239.         {     
  240.             Marshal.FreeHGlobal(buffer);     
  241.         }     
  242.     }     
  243.     //字节数组转结构体     
  244.     public object BytesToStruct(byte[] bytes,   Type   strcutType)     
  245.     {     
  246.         int size = Marshal.SizeOf(strcutType);     
  247.         IntPtr buffer = Marshal.AllocHGlobal(size);     
  248.         try  
  249.         {     
  250.             Marshal.Copy(bytes,0,buffer,size);     
  251.             return  Marshal.PtrToStructure(buffer,   strcutType);     
  252.         }     
  253.         finally  
  254.         {     
  255.             Marshal.FreeHGlobal(buffer);     
  256.         }        
  257.          
  258.     }     
  259.          
  260.     private void sendCallback (IAsyncResult asyncSend)     
  261.     {     
  262.          
  263.     }     
  264.          
  265.     //关闭Socket     
  266.     public void Closed()     
  267.     {     
  268.          
  269.         if(clientSocket != null && clientSocket.Connected)     
  270.         {     
  271.             clientSocket.Shutdown(SocketShutdown.Both);     
  272.             clientSocket.Close();     
  273.         }     
  274.         clientSocket = null;     
  275.     }     
  276.          
  277. }  

为了与服务端达成默契，推断数据包是否完毕。我们须要在数据包中定义包头 。包头通常是这个数据包的长度，也就是结构体对象的长度。正如代码中我们把两个数据类型 short 和 object 合并成一个新的字节数组。

然后是数据包结构体的定义。须要注意假设你在做IOS和Android的话数据包中不要包括数组，不然在结构体转换byte数组的时候会出错。

Marshal.StructureToPtr () error : Attempting to JIT compile method

JFPackage.cs

[c#] view plaincopy
  1. using UnityEngine;     
  2. using System.Collections;     
  3. using System.Runtime.InteropServices;     
  4.          
  5. public class JFPackage     
  6. {     
  7.     //结构体序列化     
  8.     [System.Serializable]     
  9.     //4字节对齐 iphone 和 android上能够1字节对齐     
  10.     [StructLayout(LayoutKind.Sequential, Pack = 4)]     
  11.     public struct WorldPackage     
  12.     {     
  13.          public byte mEquipID;     
  14.          public byte mAnimationID;     
  15.          public byte mHP;     
  16.          public short mPosx;     
  17.          public short mPosy;     
  18.          public short mPosz;     
  19.          public short mRosx;     
  20.          public short mRosy;     
  21.          public short mRosz;     
  22.          
  23.          public WorldPackage(short posx,short posy,short posz, short rosx, short rosy, short rosz,byte equipID,byte animationID,byte hp)     
  24.          {     
  25.             mPosx = posx;     
  26.             mPosy = posy;     
  27.             mPosz = posz;     
  28.             mRosx = rosx;     
  29.             mRosy = rosy;     
  30.             mRosz = rosz;     
  31.             mEquipID = equipID;     
  32.             mAnimationID = animationID;     
  33.             mHP = hp;     
  34.          }     
  35.          
  36.     };       
  37.          
  38. }  

在脚本中运行发送数据包的动作，在Start方法中得到Socket对象。

[c#] view plaincopy
  1. public JFSocket mJFsorket;     
  2.          
  3. void Start ()     
  4. {     
  5.     mJFsorket = JFSocket.GetInstance();     
  6. }  

让角色发生移动的时候。调用该方法向服务端发送数据。

[c#] view plaincopy
  1. void SendPlayerWorldMessage()     
  2. {     
  3.                 //组成新的结构体对象，包含主角坐标旋转等。     
  4.      Vector3 PlayerTransform = transform.localPosition;     
  5.      Vector3 PlayerRotation = transform.localRotation.eulerAngles;     
  6.                 //用short的话是2字节。为了节省包的长度。这里乘以100 避免使用float 4字节。

    当server接受到的时候小数点向前移动两位就是真实的float数据     

  7.      short px =  (short)(PlayerTransform.x*100);     
  8.      short py =  (short)(PlayerTransform.y*100);     
  9.      short pz =  (short)(PlayerTransform.z*100);     
  10.      short rx =  (short)(PlayerRotation.x*100);     
  11.      short ry =  (short)(PlayerRotation.y*100);     
  12.      short rz =  (short)(PlayerRotation.z*100);     
  13.      byte equipID = 1;     
  14.      byte animationID =9;     
  15.      byte hp = 2;     
  16.      JFPackage.WorldPackage wordPackage = new JFPackage.WorldPackage(px,py,pz,rx,ry,rz,equipID,animationID,hp);     
  17.                 //通过Socket发送结构体对象     
  18.      mJFsorket.SendMessage(wordPackage);     
  19. }  

接着就是client同步server的数据，眼下是測试阶段所以写的比較简陋，只是原理都是一样的。

哇咔咔！！

[c#] view plaincopy
  1. //上次同步时间     
  2.       private float mSynchronous;     
  3.          
  4. void Update ()     
  5. {     
  6.          
  7.     mSynchronous +=Time.deltaTime;     
  8.     //在Update中每0.5s的时候同步一次     
  9.     if(mSynchronous > 0.5f)     
  10.     {     
  11.         int count = mJFsorket.worldpackage.Count;     
  12.         //当接受到的数据包长度大于0 開始同步     
  13.         if(count > 0)     
  14.         {     
  15.                                //遍历数据包中 每一个点的坐标     
  16.             foreach(JFPackage.WorldPackage wp in mJFsorket.worldpackage)     
  17.             {     
  18.                 float x = (float)(wp.mPosx / 100.0f);     
  19.                 float y = (float)(wp.mPosy /100.0f);     
  20.                 float z = (float)(wp.mPosz /100.0f);     
  21.          
  22.                 Debug.Log("x = " + x + " y = " + y+" z = " + z);     
  23.                   //同步主角的新坐标     
  24.                 mPlayer.transform.position = new Vector3 (x,y,z);     
  25.             }     
  26.                                //清空数据包链表     
  27.             mJFsorket.worldpackage.Clear();     
  28.         }     
  29.         mSynchronous = 0;     
  30.     }     
  31. }  

主角移动的同一时候。通过Socket时时同步坐标喔。。

有没有感觉这个牛头人很帅气 哈哈哈。

技术分享

对于Socket的使用，我相信没有比MSDN更加具体的了。

有关Socket 同步请求异步请求的地方能够參照MSDN  链接地址给出来了，好好学习吧，嘿嘿。 msdn.microsoft.com/zh-cn/library/system.net.sockets.socket.aspx

上述代码中我使用的是Thread() 没有使用协同任务StartCoroutine() 。原因是协同任务必须要继承MonoBehaviour，而且该脚本要绑定在游戏对象身上。问题绑定在游戏对象身上切换场景的时候这个脚本必定会释放，那么Socket肯定会断开连接。所以我须要用Thread，而且协同任务它并非严格意义上的多线程。

2.HTTP

HTTP请求在Unity我相信用的会更少一些，由于HTTP会比SOCKET慢非常多，由于它每次请求完都会断开。废话不说了， 我用HTTP请求制作用户的登录。

用HTTP请求直接使用Unity自带的www类就能够，由于HTTP请求仅仅有登录才会有， 所以我就在脚本中来完毕， 使用 www 类 和 协同任务StartCoroutine()。

[c#] view plaincopy
  1. using UnityEngine;     
  2. using System.Collections;     
  3. using System.Collections.Generic;     
  4. public class LoginGlobe : MonoBehaviour {     
  5.          
  6.     void Start ()     
  7.     {     
  8.         //GET请求     
  9.         StartCoroutine(GET("http://xuanyusong.com/"));     
  10.          
  11.     }     
  12.          
  13.     void Update ()     
  14.     {     
  15.          
  16.     }     
  17.          
  18.     void OnGUI()     
  19.     {     
  20.          
  21.     }     
  22.          
  23.     //登录     
  24.     public void LoginPressed()     
  25.     {     
  26.         //登录请求 POST 把參数写在字典用 通过www类来请求     
  27.         Dictionary<string,string> dic = new Dictionary<string, string> ();     
  28.         //參数     
  29.         dic.Add("action","0");     
  30.         dic.Add("usrname","xys");     
  31.         dic.Add("psw","123456");     
  32.          
  33.         StartCoroutine(POST("http://192.168.1.12/login.php",dic));     
  34.          
  35.     }     
  36.     //注冊     
  37.     public void SingInPressed()     
  38.     {     
  39.         //注冊请求 POST     
  40.         Dictionary<string,string> dic = new Dictionary<string, string> ();     
  41.         dic.Add("action","1");     
  42.         dic.Add("usrname","xys");     
  43.         dic.Add("psw","123456");     
  44.          
  45.         StartCoroutine(POST("http://192.168.1.12/login.php",dic));     
  46.     }     
  47.          
  48.     //POST请求     
  49.     IEnumerator POST(string url, Dictionary<string,string> post)     
  50.     {     
  51.         WWWForm form = new WWWForm();     
  52.         foreach(KeyValuePair<string,string> post_arg in post)     
  53.         {     
  54.             form.AddField(post_arg.Key, post_arg.Value);     
  55.         }     
  56.          
  57.         WWW www = new WWW(url, form);     
  58.         yield return www;     
  59.          
  60.         if (www.error != null)     
  61.         {     
  62.             //POST请求失败     
  63.             Debug.Log("error is :"+ www.error);     
  64.          
  65.         } else  
  66.         {     
  67.             //POST请求成功     
  68.              Debug.Log("request ok : " + www.text);     
  69.         }     
  70.     }     
  71.          
  72.     //GET请求     
  73.     IEnumerator GET(string url)     
  74.     {     
  75.          
  76.         WWW www = new WWW (url);     
  77.         yield return www;     
  78.          
  79.         if (www.error != null)     
  80.         {     
  81.             //GET请求失败     
  82.             Debug.Log("error is :"+ www.error);     
  83.          
  84.         } else  
  85.         {     
  86.             //GET请求成功     
  87.              Debug.Log("request ok : " + www.text);     
  88.         }     
  89.     }     
  90.          
  91. }  

假设想通过HTTP传递二进制流的话 能够使用 以下的方法。

[c#] view plaincopy
  1. WWWForm wwwForm = new WWWForm();     
  2.          
  3.      byte[] byteStream = System.Text.Encoding.Default.GetBytes(stream);     
  4.          
  5.      wwwForm.AddBinaryData("post", byteStream);     
  6.          
  7.      www = new WWW(Address, wwwForm);  

眼下Socket数据包还是没有进行加密算法。后期我会补上。

欢迎讨论。互相学习互相进度 加油，蛤蛤。

下载地址我不贴了。由于没有服务端的东西 执行也看不到效果。

希望大家学习愉快， 我们下次再见！

 

Unity3D 游戏引擎之C#使用Socket与HTTP连接server数据传输包

标签：索引   generic   数组   计算   int   stream   coroutine   cti   多线程   

原文地址：http://www.cnblogs.com/yfceshi/p/6893599.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！