tcp unity3d_unity3d tcp连接 - CSDN
精华内容
参与话题
  • 自己设计的一套实用的针对中小型网络游戏的网络通信框架

    大家好,我是FoldCc,今天给大家分享一下自己设计并且经常用到的一个网络通信框架---客户端

    经过自己的实践,发现这套框架在应对一些中小型手游还是比较稳定使用的,整体结构也比较简单,但是特别实用,唯一要注意一点的是在开发网络通信时,一定要注意多线程争用资源的问题。

    下面我为大家详细介绍一下:

    首先最核心的是Socket连接器 它的功能主要有4个

    》向服务器发起连接请求

    》一个能够返回已经连接服务器的Socket的方法(仅用于之后开启接收和发送消息线程)

    》判断当前是否连接正常

    》断开服务器连接

    当连接器连接成功后会自动创建两个线程,分别用来接收和发送,(至于为什么要单独分开成两个,是因为在实际应用中一个线程处理这两个效率上低,容易出问题,并且理论上来说一个线程同时处理发送和接收也有点不合理)为了防止接收和发送线程在处理消息可能出现效率跟不上的问题,我设置了两个消息队列,分别用来装发送的消息和接收的消息,其中接收的消息通过消息分类器分类到不同队列中,这里需要注意的一点是,接收消息需要做粘包处理!说通俗一点就是判断消息的完整性,这里我为所有消息都加了一个特定的消息头 和消息尾 用来判断消息的完整性,至于消息头和消息尾的内容由自己设计,最好是不常使用的一些特殊字符,防止遇到和内容相同的情况。

    两个线程则只负责将收到的消息往队列中存储以及将发送队列的消息按顺序发送就行了,消息分类会单独去对消息进行分类并存放到对应队列中。

    下面是这一套框架的流程图,如果有用大家帮忙转载哦!大笑

    展开全文
  • HiSocket unity中的socket通信

    千次阅读 2018-08-10 17:10:01
    开源地址:https://github.com/hiramtan/HiSocket_unity ...Tcp socket Udp socket 可伸缩字节表 高性能字节块缓冲区 消息注册和回调 二进制字节消息封装 Protobuf消息封装 AES消息加密 详情 T...

    开源地址:https://github.com/hiramtan/HiSocket

    HiSocket

    轻量Socket通信逻辑,可以在C#项目或Unity3d项目中使用.

    PackagistBuild Status GitHub release


    如何使用

    可以选择使用dll或者使用源码,把它添加到自己的工程中即可使用.
    - Dll: HiSocket_xx.zip
    - 源码: 源码

    快速开始:

            //tcp example
            private IPackage package = new PackageExample();
            private TcpConnection tcp;
            void Init()
            {
                tcp = new TcpConnection(package);
                tcp.OnConnected += OnConnected;
                tcp.OnReceive += OnReceive;
                //...
                //...
                tcp.Connect("127.0.0.1",999);
            }
            void OnConnected()
            {
                //connect success
                tcp.Send(new byte[10]);//send message
            }
    
            void OnReceive(byte[] bytes)
            {
                //get message from server
            }

    更多示例:
    - C#项目示例:示例
    - Unity项目示例:示例


    总览

    项目包含:
    - Connection
    - TcpConnection
    - TcpSocket
    - Package
    - UdpConnection
    - UdpSocket
    - Plugin
    - Message
    - Message register
    - Aes encryption
    - Byte message
    - Protobuf message

    功能

    • Tcp socket
    • Udp socket
    • 可伸缩字节表
    • 高性能字节块缓冲区
    • 消息注册和回调
    • 二进制字节消息封装
    • Protobuf消息封装
    • AES消息加密

    详情

    • Tcp和Udp都是采用主线程异步连接的方式(避免主线程阻塞).
    • 高性能字节缓冲区避免内存空间重复申请,减少GC.
    • 可以添加一系列的事件监听获取当前的连接状态.
    • 如果使用Tcp协议需要实现IPackage接口处理粘包拆包.
    • 如果使用Udp协议需要声明缓冲区大小.
    • Ping: 源码包含一个Ping插件可以使用,但是如果用在unity3d工程中会报错(因为mono的问题,在.net2.0会报错.net4.6可以正常使用)

    高级功能

    • 如果对Socket很熟悉,也可以使用TcpSocket(UdpSocket)来实现功能,但是还是推荐使用TcpConnection(UdpConnection)的方式.
    • 通过接口可以访问底层Socket对象扩展逻辑,比如修改超时时间.
    • 通过接口可以获得发送接收缓冲区,比如断开连接时是否要将发送缓冲区数据全部发出?重连后怎样处理发送缓冲区的数据.
    • OnSocketReceive和OnReceive是不同的,比如当OnSocketReceive接受大小是100字节,当用户解包时不做操作,OnReceive大小是100字节,当用户解包时做解压缩(解密等)操作后,OnReceive大小不再是100.
    • 可以向TcpConnection(UdpConnection)添加不同的插件完成所需的功能,
    • 注册基类可以方便快速注册消息(基于反射)
    • Byte block buffer 采用有序链表实现,当有区块空闲时会重用区块.

    - .etc

    介绍

    Tcp 协议提供可靠有序的流字节传输,用户需要自己分割数据,在这个框架中可以继承IPackage接口来实现.

    Tcp协议传输字节流,用户需要分割字节流获得正确的数据包,当创建一个tcp协议的socket时,需要传入一个Package对象来封包和解包.

    最初创建连接时我们定义了一个packer来分割数据包,当发送消息时我们在数据头部插入消息长度/当接收到消息时我们根据头部的消息长度获得数据包的大小.

    Udp协议提供不可靠的报文消息,用户无法知道当前连接状态,但是消息包时完整的.

    如果创建upd连接,需要指定发送接收缓冲区大小.

    • Ping :
      因为mono在.net2.0和2.0 subset的bug,可以在unity3d使用如下逻辑获取ping值.
      csharp
      public int PingTime;
      private Ping p;
      private float timeOut = 1;
      private float lastTime;
      void Start()
      {
      StartCoroutine(Ping());
      }
      IEnumerator Ping()
      {
      p = new Ping("127.0.0.1");
      lastTime = Time.realtimeSinceStartup;
      while (!p.isDone && Time.realtimeSinceStartup - lastTime < 1)
      {
      yield return null;
      }
      PingTime = p.time;
      p.DestroyPing();
      yield return new WaitForSeconds(1);
      StartCoroutine(Ping());
      }
    • 消息注册
    • Protobuf
    • 字节消息
    • 加密

    Example

    HiSocketExampleHiSocket.unitypackage有很多示例, 其中有一些如下:

    Package example:

    /// <summary>
        /// Example: Used to pack or unpack message
        /// You should inheritance IPackage interface and implement your own logic
        /// </summary>
        class PackageExample : IPackage
        {  /// <summary>
           /// Pack your message here(this is only an example)
           /// </summary>
           /// <param name="source"></param>
           /// <param name="unpackedHandler"></param>
            public void Unpack(IByteArray source, Action<byte[]> unpackedHandler)
            {
                // Unpack your message(use int, 4 byte as head)
                while (source.Length >= 4)
                {
                    var head = source.Read(4);
                    int bodyLength = BitConverter.ToInt32(head, 0);// get body's length
                    if (source.Length >= bodyLength)
                    {
                        var unpacked = source.Read(bodyLength);// get body
                        unpackedHandler(unpacked);
                    }
                    else
                    {
                        source.Insert(0, head);// rewrite in, used for next time
                    }
                }
            }
    
            /// <summary>
            /// Unpack your message here(this is only an example)
            /// </summary>
            /// <param name="source"></param>
            /// <param name="packedHandler"></param>
            public void Pack(IByteArray source, Action<byte[]> packedHandler)
            {
                // Add head length to your message(use int, 4 byte as head)
                var length = source.Length;
                var head = BitConverter.GetBytes(length);
                source.Insert(0, head);// add head bytes
                var packed = source.Read(source.Length);
                packedHandler(packed);
            }
        }
    private IPackage _package = new PackageExample();
            private TcpConnection _tcp;
            static void Main(string[] args)
            {
    
            }
            void Init()
            {
                _tcp = new TcpConnection(_package);
                _tcp.OnConnected += OnConnected;
                _tcp.OnReceive += Receive;
                //_tcp.OnError
                //_tcp.OnDisconnected
            }
            void OnConnected()
            {
                //connect success
                _tcp.Send(new byte[10]);//send message
                _tcp.DisConnect();//disconnect
            }
    
            void Receive(byte[] bytes)
            {
                //get message from server
            }
     void Init()
            {
                var tcp = new TcpConnection(new PackageExample());
                tcp.AddPlugin(new PingPlugin("ping", tcp));
                //tcp.GetPlugin("ping");
            }

    点击链接加入QQ群【83596104】:https://jq.qq.com/?_wv=1027&k=5l6rZEr

    support: hiramtan@live.com

    展开全文
  • Unity3D Socket通信 TCP

    千次阅读 2017-09-20 17:51:17
    TCP的特性 1.TCP只会寻址一次 2.TCP 是有序的 3.TCP链接的时候有三次握手 如图 4.TCP断开链接的时候需要四次握手 如图 整体流程 服务端using System.Collections; using System.Collections.Generic; using ...

    TCP的特性
    1.TCP只会寻址一次
    2.TCP 是有序的
    3.TCP链接的时候有三次握手 如图
    这里写图片描述

    4.TCP断开链接的时候需要四次握手 如图
    这里写图片描述

    整体流程
    这里写图片描述

    服务端

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    //引用两个命名空间
    using System.Net;
    using System.Net.Sockets;
    using System;
    //引用线程的命名空间
    using System.Threading;
    
    public class SocketState
    {
        Socket ClientSocket;
        /// <summary>
        /// 存放接收到的字节流
        /// </summary>
        byte[] ReciveDataBytes = new byte[1024];
        public SocketState(Socket temSocket)
        {
            ClientSocket = temSocket;
        }
        /// <summary>
        /// 客户端向服务器端的链接请求
        /// </summary>
        public void ConnectRequest(string ip,int port)
        {
            IPEndPoint IP = new IPEndPoint(IPAddress.Parse(ip),port);
            ClientSocket.BeginConnect(IP, ConnectCallBack,null);
        }
        /// <summary>
        /// 发送链接请求的回调函数
        /// </summary>
        /// <param name="ar"></param>
        public void ConnectCallBack(IAsyncResult ar)
        {
            //ClientSocket.EndSend(ar)   表示跟服务器成功连接
            ClientSocket.EndConnect(ar);
        }
        /// <summary>
        /// 发送函数
        /// </summary>
        /// <param name="buffer">发送的字节流</param>
        public void SendData(byte[] buffer)
        {
    
            //发送
            //buffer  发送的字节流
            //0 偏移量 从buffer第0个字节开始
            //buffer.Length 读取长度为buffer的长度
            //SocketFlags.None 
            //SendCallBack 回调函数
            ClientSocket.BeginSend(buffer,0,buffer.Length,SocketFlags.None, SendCallBack,null);Debug.Log(buffer.Length);
        }
        /// <summary>
        /// 发送成功的回调函数
        /// </summary>
        /// <param name="ar"></param>
        public void SendCallBack(IAsyncResult ar)
        {
            //ClientSocket.EndSend(ar) 返回值类型为int  表示成功发送了多少个字节流
            int SendCount = ClientSocket.EndSend(ar);
            Debug.Log("send" + SendCount);
        }
        /// <summary>
        /// 接收函数
        /// </summary>
        /// <param name="buffer">发送的字节流</param>
        public void ReciveData()
        {
            //接收
            //ReciveDataBytes  接收的字节流
            //0 偏移量 从ReciveDataBytes第0个字节开始
            //ReciveDataBytes.Length 读取长度为ReciveDataBytes的长度
            //SocketFlags.None 
            //ReciveCallBack 回调函数
            ClientSocket.BeginReceive(ReciveDataBytes,0, ReciveDataBytes.Length,SocketFlags.None, ReciveCallBack, null);
        }
        /// <summary>
        /// 接收成功的回调函数
        /// </summary>
        /// <param name="ar"></param>
        public void ReciveCallBack(IAsyncResult ar)
        {
            //ClientSocket.EndSend(ar) 返回值类型为int  表示成功接收了多少个字节流
            int ReciveCount = ClientSocket.EndReceive(ar);
            Debug.Log("ReciveCount" + ReciveCount);
        }
    }
    public class TCPSever : MonoBehaviour {
    
    
        Socket severSocket;
        /// <summary>
        /// 端口号  和此端口号绑定
        /// </summary>
        public int port = 18001;
        /// <summary>
        /// 声明一个线程
        /// </summary>
        private Thread TemThread;
        /// <summary>
        /// 线程控制
        /// </summary>
        private bool IsRuningRecive = true;
        /// <summary>
        /// 存放客户端的映射
        /// </summary>
        List<SocketState> ClientSocketList;
        public void Init()
        {
    
            //AddressFamily 表示地址协议族 IPV4  IPV6
            //SocketType.Stream 数据报格式----> TCP
            //ProtocolType.Tcp  采用的哪种协议 
            severSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
            //获得一个ip
            IPEndPoint ip = new IPEndPoint(IPAddress.Any, port);
            //绑定ip
            severSocket.Bind(ip);
            //实例化线程
            TemThread = new Thread(ReciveThread);
            //开启线程
            TemThread.Start();
            //实例化List
            ClientSocketList = new List<SocketState>();
        }
        /// <summary>
        /// 接收线程
        /// </summary>
        public void ReciveThread()
        {
            while (IsRuningRecive)
            {
                //异步 接收
                //ReciveCallBack  回调函数
                //null 如果不需要就传null就可以了
                severSocket.BeginAccept(ReciveCallBack,null);
                //每隔100毫秒监听一次是否有客户端发送请求
                Thread.Sleep(100);
            }
        }
        /// <summary>
        /// 回调函数  有客户端请求就会调用
        /// </summary>
        /// <param name="ar"></param>
        public void ReciveCallBack(IAsyncResult ar)
        {
            //severSocket.EndAccept(ar.AsyncState) 返回值就是客户端的映射  需要我们保存下来
            Socket ClientSocket = severSocket.EndAccept(ar);
            //实例化一个SocketState
            SocketState temSocketState = new SocketState(ClientSocket);
            //添加到List
            ClientSocketList.Add(temSocketState);
        }
    
        // Use this for initialization
        void Start () {
            Init();
        }
    
        // Update is called once per frame
        void Update () {
            //不断的请求询问客户端
            for (int i = 0; i < ClientSocketList.Count; i++)
            {
                ClientSocketList[i].ReciveData();
            }
        }
    }
    

    客户端

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    //引用两个命名空间
    using System.Net;
    using System.Net.Sockets;
    
    public class TCPClient : MonoBehaviour {
    
        SocketState clientSocket;
        // Use this for initialization
        void Start () {
            Socket temSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
    
            clientSocket = new SocketState(temSocket);
    
            clientSocket.ConnectRequest("127.0.0.1",18001);    
        }
    
        // Update is called once per frame
        void Update () {
    
    
            if (Input.GetMouseButtonDown(0))
            {
                byte[] temB = System.Text.Encoding.Default.GetBytes("123456");
                clientSocket.SendData(temB);
            }
            if (clientSocket != null)
            {
                clientSocket.ReciveData();
            }
        }
    }
    
    展开全文
  • 转自:https://blog.csdn.net/hiramtan/article/details/72621787开源地址:https://github.com/hiramtan/HiSocket_unityHiSocket_unity如何使用可以从此链接下载最新的unity package: 功能Tcp socketUdp socket可...

    转自:https://blog.csdn.net/hiramtan/article/details/72621787

    开源地址:https://github.com/hiramtan/HiSocket_unity

    HiSocket_unity


    如何使用

    可以从此链接下载最新的unity package: Github Releases


    功能

    • Tcp socket
    • Udp socket
    • 可伸缩字节表
    • 高性能字节块缓冲区
    • 消息注册和回调
    • 二进制字节消息封装
    • Protobuf消息封装
    • AES消息加密

    详情

    • Tcp和Udp都是采用主线程异步连接的方式(避免主线程阻塞).
    • 启动发送线程和接收线程处理数据传输(提高性能).
    • 供用户调用发送或接受数据的API在主线程中(方便直接操作unity的组件)
    • 监听连接事件获得当前的连接状态.
    • 监听接收事件获得接收的数据.
    • 存在字节数组队列,方便用来测试和数据重发.
    • 高性能字节缓冲区避免内存空间重复申请,减少GC.
    • 如果使用Tcp协议需要实现IPackage接口处理粘包拆包.
    • Ping接口因为mono底层的bug会在.net2.0平台报错(.net 4.6 没有问题,或者也可以使用unity的接口获得Ping,工程中有示例代码)

    细节

    • Tcp 
      Transmission Control Protocol

      • Tcp connection 
        Tcp协议传输字节流,用户需要分割字节流获得正确的数据包,当创建一个tcp协议的socket时,需要传入一个Package对象来封包和解包.

        private IPackage _packer = new Packer();
        void Test()
        {
         _tcp = new TcpConnection(_packer);
        }
        
        public class Packer : IPackage
        {
            public void Unpack(IByteArray reader, Queue<byte[]> receiveQueue)
            {
               //add your unpack logic here
           }
        
           public void Pack(Queue<byte[]> sendQueue, IByteArray writer)
           {
               // add your pack logic here
           }
        }
        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
      • 连接

        _tcp.Connect("127.0.0.1", 7777);
        • 1
      • 断开连接 
        当不再运行时需要主动调用接口断开与服务器的连接(比如响应unity的onapplicationquit执行时)

        void OnApplicationQuit()
        {
            _tcp.DisConnect();
        }
        • 1
        • 2
        • 3
        • 4
      • 连接状态变化 
        如果想获取当前的连接状态,可以订阅连接状态事件.

        void Test()
        {
            _tcp.StateChangeEvent += OnState;
        }
        void OnState(SocketState state)
        {
            Debug.Log("current state is: " + state);
            if (state == SocketState.Connected)
            {
                Debug.Log("connect success");
                //can send or receive message
            }
            else if (state == SocketState.DisConnected)
            {
                Debug.Log("connect failed");
            }
            else if (state == SocketState.Connecting)
            {
                Debug.Log("connecting");
            }
        }
        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
      • 发送消息

        void Test()
        {
            var bytes = BitConverter.GetBytes(100);
            _tcp.Send(bytes);
        }
        • 1
        • 2
        • 3
        • 4
        • 5
      • 接受消息 
        You can regist receiveevent and when message come from server, this event will be fire.

            void Test()
            {
                _tcp.ReceiveEvent += OnReceive;
            }
            void OnReceive(byte[] bytes)
            {
                Debug.Log("receive msg: " + BitConverter.ToInt32(bytes, 0));
            }
        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
      • 封包和解包 
        最初创建连接时我们定义了一个packer来分割数据包,当发送消息时我们在数据头部插入消息长度/当接收到消息时我们根据头部的消息长度获得数据包的大小.

        private bool _isGetHead = false;
        private int _bodyLength;
        public void Unpack(IByteArray reader, Queue<byte[]> receiveQueue)
        {
            if (!_isGetHead)
            {
                if (reader.Length >= 2)//2 is example, get msg's head length
                {
                    var bodyLengthBytes = reader.Read(2);
                    _bodyLength = BitConverter.ToUInt16(bodyLengthBytes, 0);
                }
                else
                {
                    if (reader.Length >= _bodyLength)//get body
                    {
                        var bytes = reader.Read(_bodyLength);
                        receiveQueue.Enqueue(bytes);
                        _isGetHead = false;
                    }
                }
            }
        }
        public void Pack(Queue<byte[]> sendQueue, IByteArray writer)
        {
            var bytesWaitToPack = sendQueue.Dequeue();
            UInt16 length = (UInt16)bytesWaitToPack.Length;//get head lenth
            var bytesHead = BitConverter.GetBytes(length);
            writer.Write(bytesHead);//write head
            writer.Write(bytesWaitToPack);//write body
        }
        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
    • Udp

      • Udp connection 
        如果创建upd连接,需要指定发送接收缓冲区大小.

        _udp = new UdpConnection(1024);
        • 1
    • Ping

      public int PingTime;
      private Ping p;
      private float timeOut = 1;
      private float lastTime;
      void Start()
      {
          StartCoroutine(Ping());
      }
      IEnumerator Ping()
      {
          p = new Ping("127.0.0.1");
          lastTime = Time.realtimeSinceStartup;
          while (!p.isDone && Time.realtimeSinceStartup - lastTime < 1)
          {
              yield return null;
          }
          PingTime = p.time;
          p.DestroyPing();
          yield return new WaitForSeconds(1);
          StartCoroutine(Ping());
      }
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
    • 消息注册
    • Protobuf
    • 字节消息
    • 加密

    Tcp Example

    Tcp 协议提供可靠有序的流字节传输,用户需要自己分割数据,在这个框架中可以继承IPackage接口来实现.

        private ITcp _tcp;
        private IPackage _packer = new Packer();
        // Use this for initialization
        void Start()
        {
            _tcp = new TcpConnection(_packer);
            _tcp.StateChangeEvent += OnState;
            _tcp.ReceiveEvent += OnReceive;
            Connect();
        }
        void Update()
        {
            _tcp.Run();
        }
    
        void Connect()
        {
            _tcp.Connect("127.0.0.1", 7777);
        }
        // Update is called once per frame
    
        void OnState(SocketState state)
        {
            Debug.Log("current state is: " + state);
            if (state == SocketState.Connected)
            {
                Debug.Log("connect success");
                Send();
            }
            else if (state == SocketState.DisConnected)
            {
                Debug.Log("connect failed");
            }
            else if (state == SocketState.Connecting)
            {
                Debug.Log("connecting");
            }
        }
        void OnApplicationQuit()
        {
            _tcp.DisConnect();
        }
        void Send()
        {
            for (int i = 0; i < 10; i++)
            {
                var bytes = BitConverter.GetBytes(i);
                Debug.Log("send message: " + i);
                _tcp.Send(bytes);
            }
        }
        void OnReceive(byte[] bytes)
        {
            Debug.Log("receive msg: " + BitConverter.ToInt32(bytes, 0));
        }
        public class Packer : IPackage
        {
            public void Unpack(IByteArray reader, Queue<byte[]> receiveQueue)
            {
                //add your unpack logic here
                if (reader.Length >= 1024)//1024 is example, it's msg's length
                {
                    var bytesWaitToUnpack = reader.Read(1024);
                    receiveQueue.Enqueue(bytesWaitToUnpack);
                }
            }
    
            public void Pack(Queue<byte[]> sendQueue, IByteArray writer)
            {
                var bytesWaitToPack = sendQueue.Dequeue();
                // add your pack logic here
                //
    
                writer.Write(bytesWaitToPack);
            }
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76

    Udp Example

    User Datagram Protocol

    Udp协议提供不可靠的报文消息,用户无法知道当前连接状态,但是消息包时完整的.

        private UdpConnection _udp;
        // Use this for initialization
        void Start()
        {
            _udp = new UdpConnection(1024);
            _udp.ReceiveEvent += OnReceive;
            Connect();
            Send();
        }
        void Connect()
        {
            _udp.Connect("127.0.0.1", 7777);
        }
        // Update is called once per frame
        void Update()
        {
            _udp.Run();
        }
        void Send()
        {
            for (int i = 0; i < 10; i++)
            {
                var bytes = BitConverter.GetBytes(i);
                _udp.Send(bytes);
                Debug.Log("send message: " + i);
            }
        }
        private void OnApplicationQuit()
        {
            _udp.DisConnect();
        }
        void OnReceive(byte[] bytes)
        {
            Debug.Log("receive bytes: " + BitConverter.ToInt32(bytes, 0));
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    Message Registration Example

        void RegistMsg()
        {
            MsgRegister.Regist("10001", OnMsg_Bytes);
            MsgRegister.Regist("10002", OnMsg_Protobuf);
        }
    
        void OnMsg_Bytes(IByteArray byteArray)
        {
            var msg = new MsgBytes(byteArray);
            int getInt = msg.Read<int>();
        }
    
        void OnMsg_Protobuf(IByteArray byteArray)
        {
            var msg = new MsgProtobuf(byteArray);
            GameObject testClass = msg.Read<GameObject>();//your class's type
            var testName = testClass.name;
        }
    展开全文
  • Unity3D上进行TCP Client的创建与通讯

    千次阅读 2019-01-10 12:43:00
    Unity3D上进行TCP Client的创建与通讯简介代码 简介 Unity3D版本: 2018.3.0f2 Personal Visual Studio版本:2017 在Unity3D上连接TCP Server建立通讯 建立通讯后进行双向数据传输 代码 创建文件TCPUDPSocket.cs ...
  • 经过一段时间的学习,对于TCP/IP协议有了一定的认识,大概知道了TCP协议通信的原理,接下来主要实现用TcpClient、TcpListener两个封装类和stream来实现一个小的demo:用vs建一个工程作为服务器,然后用Unity引擎作为...
  • Unity3D应用嵌入WPF应用并实现通信

    千次阅读 热门讨论 2017-06-10 17:12:22
    由于Unity3D在5.4.x版本后不再支持WebPlayer,所以并未使用UnityWebPlayer,另外考虑到我们原有的业务系统都是基于WPF的,全部改到Unity3D里面工作量会很大,所以采用了将Unity3D生成的exe可执行程序直接嵌入到WPF中...
  • Unity3d实战之Unity3d网络游戏实战篇(3):网络基础之TCP协议 学习书籍《Unity3d网络游戏实战》 罗培羽著 机械工业出版社 本文是作者在学习过程中遇到的认为值得记录的点,因此引用的代码等资源基本出资罗培羽...
  • Unity3d实战之Unity3d网络游戏实战篇(8):网络管理类ServNet 学习书籍《Unity3d网络游戏实战》 罗培羽著 机械工业出版社 本文是作者在学习过程中遇到的认为值得记录的点,因此引用的代码等资源基本出资罗培羽...
  • 已入强化学习一个学期了,发现自己急需一个物理环境来进行训练机器人,前前后后参考过过许多环境,但是最后选择了Unity3D,这是因为其足够简单,不用费很大的功夫就可以建立一个简易的机器人,只需要编写C#脚本和...
  • unity3d socket TCP 异步连接数据

    千次阅读 2014-04-23 14:16:20
    using UnityEngine; using System.Collections; using System; using System.Threading; using System.Text; using System.Net; using System.Net.Sockets; using System.Collections....using System
  • Unity3d自带非常好用的性能分析工具:Profiler 以下为Android平台下Unity3d应用的Profiler的使用步骤: 1. 发布Untiy Android APK时,勾选“Development Build”和“AutoConnect Profiler”选项 2. 将Android...
  • 出售客户端socket通信插件¥20,自己搭建的成本远高于¥20....1.客户端socket通信插件!经过测试兼容window/linux/mac/ios(兼容jit编译)/Android/windows phone系统平台....3.符合unity3d程序员习惯,upd
  • 简单的基于Unity的客户端连接服务器端,相互发送一次数据,文档描述位于http://blog.sina.com.cn/s/blog_1322690230102y3l4.html
  • Unity3d笔试题大全

    千次阅读 2018-01-06 16:36:58
    Unity3d笔试题大全 1. [C#语言基础]请简述拆箱和装箱。 答: 装箱操作: 值类型隐式转换为object类型或由此值类型实现的任何接口类型的过程。 1.在堆中开辟内存空间。 2.将值类型的数据复制到堆中。 3.返回堆...
  • Unity 3D 网络游戏架构设计

    千次阅读 2019-07-05 10:04:13
    本课程是 Unity 3D 系列教程,目标是带领读者搭建一个商业游戏的网络架构设计,该架构设计是游戏的核心技术,将采用 Unity 2017.2 最新版本作为开发工具。内容分为 UI 架构、技能架构、服务器和网络同步四大部分,共...
  • TCP(Transmission Control Protocol,传输控制协议)是基于连接的协议,也就是说,在正式收发数据前,必须和对方建立可靠的连接。一个TCP连接必须要经过三次“对话”才能建立起来,其中的过程非常复杂,我们这里只...
  • 今年3D产品的工作中心主要集中在提高产品深度上,通过对竞争产品的分析,发现我们的缺陷在于多人在线与后台管理部分,多人在线使用unity自带的Network可以搞定,后台部分前段时间主要研究了下Sqlite。由于sqlite本身...
  • 掌握Unity3D基本元素 1.1 简单的游戏 1.1.1在场景中创建一个立方体 1.1.2编写可以使立方体运动的程序 1.1.3测试游戏1.1.4总结1.2 资源导入1.3 山体系统1.4 灯光1.5 材质1.6 预设1.6.1制作预设1.6.2例子1.7 声音...
  • Unity3d 下websocket的使用

    万次阅读 2015-09-30 11:41:48
    今天介绍一下如何在Unity3d下使用WebSocket。 首先介绍一下websocket,socket,和http的区别与联系,然后介绍一下websocket的一些开源的项目。 WebSocket是什么 WebSocket协议是为了实现网络客户端和服务器端全...
1 2 3 4 5 ... 20
收藏数 2,026
精华内容 810
热门标签
关键字:

tcp unity3d