Unity3D入门Socket初探

最新推荐文章于 2024-04-03 11:38:01 发布
最新推荐文章于 2024-04-03 11:38:01 发布
阅读量919 收藏
点赞数



using UnityEngine;
using System;
using System.Collections;
using LSocket.Net;
using LSocket.Type;
using LSocket.cmd;
 
   public class SocketDemo : MonoBehaviour
   {
       public UnitySocket[] socket;
       public String[] textAreaString;
       public String[] textFieldString;
       public GUISkin mySkin;
       // Use this for initialization
       void Start()
       {
           socket = new UnitySocket[4];
           textAreaString = new String[12];
           for (int i = 0; i < 12; i++)
           {
               textAreaString[i] = "";
           }
           textFieldString = new String[4];
           for(int i=0;i<4;i++){
               textFieldString[i] = "";
           }
       }
 
       // Update is called once per frame
       void Update()
       {
 
       }
 
       void OnGUI()
       {
           GUI.skin = mySkin;
           for (int i = 0; i < 4; i++)
           {
               String s = textAreaString[i * 3] + "\n" + textAreaString[i * 3 + 1] + "\n" + textAreaString[i * 3 + 2];
               GUI.TextArea(new Rect(i % 2 * Screen.width / 2, i / 2 * (Screen.height / 2) + 50, 100, 60), s);
               textFieldString[i] = GUI.TextField(new Rect(i % 2 * Screen.width / 2+50, i / 2 * (Screen.height / 2), 100, 20), textFieldString[i]);
               if (GUI.Button(new Rect(i % 2 * Screen.width / 2, i / 2 * (Screen.height / 2), 40, 20), "连接"))
               {
                   socket[i] = null;
                   socket[i] = new UnitySocket();
                   socket[i].SocketConnection("192.168.0.8", 10000, this, i);
                   socket[i].DoLogin(textFieldString[i]);
               }
               else if (GUI.Button(new Rect(i % 2 * Screen.width / 2, i / 2 *( Screen.height / 2) + 25, 40, 20), "关闭"))
               {
                   if (socket[i] != null)
                   {
                       socket[i].close();
                       socket[i] = null;
                   }
               }
           }
 
           if (GUI.Button(new Rect(Screen.width - 60, Screen.height - 30, 60, 30), "退出")) {
               Application.Quit();
           }
 
       }
   }




namespace LSocket.Net
{ /**
 *
 * @author feng侠,qq:313785443
 * @date 2010-12-23
 *
 */
 
    // 描   述：封装c# socket数据传输协议
          using UnityEngine;
        using System;
        using System.Net.Sockets;
        using System.Net;
        using System.Collections;
        using System.Text;
    using System.Threading;
        using LSocket.Type;
        using LSocket.cmd;
 
 
    class SocketThread
    {
 
        UnitySocket socket;
        SocketDemo demo;
        int idx;
 
        public SocketThread(UnitySocket socket, SocketDemo demo, int idx)
        {
            this.socket = socket;
            this.demo = demo;
            this.idx = idx;
        }
 
        public void run()
        {
            while (true)
            {
                try
                {
                    String s = socket.ReceiveString();
                    demo.textAreaString[idx * 3] = demo.textAreaString[idx * 3 + 1];
                    demo.textAreaString[idx * 3 + 1] = demo.textAreaString[idx * 3 + 2];
                    demo.textAreaString[idx * 3 + 2] = s;
                    MonoBehaviour.print(s + " " + idx);
                }
                catch (Exception e)
                {
                    MonoBehaviour.print(e.ToString());
                    socket.t.Abort();
                }
            }
        }
 
    }
 
    public class UnitySocket
    {
        public Socket mSocket = null;
        public Thread t=null;
        private SocketThread st=null;
        public SocketDemo demo=null;
 
        public UnitySocket()
        {
             
        }
                public void SocketConnection(string LocalIP, int LocalPort,SocketDemo demo,int idx)
                {
            this.demo=demo;
                        mSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            try
            {
                                 
                IPAddress ip = IPAddress.Parse(LocalIP);
                IPEndPoint ipe = new IPEndPoint(ip, LocalPort);
                                mSocket.Connect(ipe);
                st =new SocketThread(this, demo, idx);
                t = new Thread(new ThreadStart(st.run));
                t.Start();
            }
            catch (Exception e)
            {
                MonoBehaviour.print(e.ToString());
            }
                }
        
        public void close(){
            mSocket.Close(0);
            mSocket=null;
        }
 
        public void DoLogin(String userName){
            try
            {
                Send(CommandID.LOGIN);
                Send(userName);
            }catch(Exception e){
                MonoBehaviour.print(e.ToString());
            }
        }
 
 
        public void Send(float data){
            byte[] longth = TypeConvert.getBytes(data, true);
            mSocket.Send(longth);
        }
 
        public float ReceiveFloat()
        {
            byte[] recvBytes = new byte[4];
            mSocket.Receive(recvBytes, 4, 0);//从服务器端接受返回信息
            float data = TypeConvert.getFloat(recvBytes, true);
            return data;
        }
 
                public void Send(short data)
                {
                        byte[] longth=TypeConvert.getBytes(data,true);
                        mSocket.Send(longth);
                }
                 
                public void Send(long data)
                {
                        byte[] longth=TypeConvert.getBytes(data,true);
                        mSocket.Send(longth);
                }
                 
                public void Send(int data)
                {
                        byte[] longth=TypeConvert.getBytes(data,true);
                        mSocket.Send(longth);
                         
                }
                 
                public void Send(string data)
                {
                        byte[] longth=Encoding.UTF8.GetBytes(data);
            Send(longth.Length);
                        mSocket.Send(longth);
                         
                }
                 
                public short ReceiveShort()
                {
                         byte[] recvBytes = new byte[2];
             mSocket.Receive(recvBytes,2,0);//从服务器端接受返回信息
                         short data=TypeConvert.getShort(recvBytes,true);
                         return data;
                }
                 
                public int ReceiveInt()
                {
                         byte[] recvBytes = new byte[4];
             mSocket.Receive(recvBytes,4,0);//从服务器端接受返回信息
                         int data=TypeConvert.getInt(recvBytes,true);
                         return data;
                }
                 
                public long ReceiveLong()
                {
                         byte[] recvBytes = new byte[8];
             mSocket.Receive(recvBytes,8,0);//从服务器端接受返回信息
                         long data=TypeConvert.getLong(recvBytes,true);
                         return data;
                }
                 
                public String ReceiveString()
                {
             int length = ReceiveInt();
             MonoBehaviour.print("Stringlen="+length);
                         byte[] recvBytes = new byte[length];
             mSocket.Receive(recvBytes,length,0);//从服务器端接受返回信息
             String data = Encoding.UTF8.GetString(recvBytes);
                         return data;
                }
                 
                 
        }
}




namespace LSocket.Type
{
    using UnityEngine;
    using System.Collections;
 
    public class TypeConvert
    {
 
        public TypeConvert()
        {
        }
 
        public  static byte[] getBytes(float s,bool asc){
            int buf = (int)(s * 100);
            return getBytes(buf,asc);
        }
    
         public static float getFloat(byte[] buf,bool asc){
            int i=getInt(buf,asc);
            float s=(float)i;
            return s/100;
        }
 
        public static byte[] getBytes(short s, bool asc)
        {
            byte[] buf = new byte[2];
            if (asc)
            {
                for (int i = buf.Length - 1; i >= 0; i--)
                {
                    buf[i] = (byte)(s & 0x00ff);
                    s >>= 8;
                }
            }
            else
            {
                for (int i = 0; i < buf.Length; i++)
                {
 
                    buf[i] = (byte)(s & 0x00ff);
                    s >>= 8;
                }
            }
            return buf;
        }
        public static byte[] getBytes(int s, bool asc)
        {
            byte[] buf = new byte[4];
            if (asc)
                for (int i = buf.Length - 1; i >= 0; i--)
                {
                    buf[i] = (byte)(s & 0x000000ff);
                    s >>= 8;
                }
            else
                for (int i = 0; i < buf.Length; i++)
                {
                    buf[i] = (byte)(s & 0x000000ff);
                    s >>= 8;
                }
            return buf;
        }
 
        public static byte[] getBytes(long s, bool asc)
        {
            byte[] buf = new byte[8];
            if (asc)
                for (int i = buf.Length - 1; i >= 0; i--)
                {
                    buf[i] = (byte)(s & 0x00000000000000ff);
                    s >>= 8;
                }
            else
                for (int i = 0; i < buf.Length; i++)
                {
                    buf[i] = (byte)(s & 0x00000000000000ff);
                    s >>= 8;
                }
            return buf;
        }
        public static short getShort(byte[] buf, bool asc)
        {
            if (buf == null)
            {
                //throw new IllegalArgumentException("byte array is null!");
            }
            if (buf.Length > 2)
            {
                //throw new IllegalArgumentException("byte array size > 2 !");
            }
            short r = 0;
            if (!asc)
                for (int i = buf.Length - 1; i >= 0; i--)
                {
                    r <<= 8;
                    r |= (short)(buf[i] & 0x00ff);
                }
            else
                for (int i = 0; i < buf.Length; i++)
                {
                    r <<= 8;
                    r |= (short)(buf[i] & 0x00ff);
                }
            return r;
        }
        public static int getInt(byte[] buf, bool asc)
        {
            if (buf == null)
            {
                // throw new IllegalArgumentException("byte array is null!");
            }
            if (buf.Length > 4)
            {
                //throw new IllegalArgumentException("byte array size > 4 !");
            }
            int r = 0;
            if (!asc)
                for (int i = buf.Length - 1; i >= 0; i--)
                {
                    r <<= 8;
                    r |= (buf[i] & 0x000000ff);
                }
            else
                for (int i = 0; i < buf.Length; i++)
                {
                    r <<= 8;
                    r |= (buf[i] & 0x000000ff);
                }
            return r;
        }
        public static long getLong(byte[] buf, bool asc)
        {
            if (buf == null)
            {
                //throw new IllegalArgumentException("byte array is null!");
            }
            if (buf.Length > 8)
            {
                //throw new IllegalArgumentException("byte array size > 8 !");
            }
            long r = 0;
            if (!asc)
                for (int i = buf.Length - 1; i >= 0; i--)
                {
                    r <<= 8;
                    r |= (buf[i] & 0x00000000000000ff);
                }
            else
                for (int i = 0; i < buf.Length; i++)
                {
                    r <<= 8;
                    r |= (buf[i] & 0x00000000000000ff);
                }
            return r;
        }
    }
}





namespace LSocket.cmd
{
    public class CommandID
    {
        /** 登陆消息命令 **/
        public static int LOGIN = 1001;
     
    }
}




package com.unity.socket;
 
 
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
 
 
public class SocketServer {
    private HashMap<String,User> userMap;
 
    public  SocketServer(){
         userMap=new HashMap<String, User>();
    }
 
    public static void main(String[] args){
        new SocketServer().startServer();
    }
 
    public void startServer()
        {
                try
                {
                        ServerSocket serverSocket = new ServerSocket(10000);
                        System.out.println("服务器开启");
            while (true){
                Socket socket = serverSocket.accept();
                System.out.println("有用户登陆进来了");
                new UserThread(socket,userMap).start();
            }
 
        }catch (Exception e){
             System.out.println("服务器出现异常！" + e);
        }
    }
}





package com.unity.socket;
 
import java.io.*;
import java.net.Socket;
import java.util.Iterator;
 
import java.io.ByteArrayOutputStream;
 
import java.io.DataOutputStream;
import java.util.HashMap;
 
 
public class UserThread extends Thread{
    /** 错误消息命令 **/
        public static final int                         ERROR = 0;
        /** 登陆消息命令 **/
        public static final int                         LOGIN = 1001;
    private Socket socket;
    private HashMap<String,User> userMap;
    private User user;
    private ByteArrayOutputStream byteOutput;
    private DataOutputStream output;
    private DataInputStream input;
 
    public UserThread(Socket socket,HashMap<String,User> userMap){
        this.socket=socket;
        this.userMap=userMap;
    }
 
    //重新初始化2个新的output
        private void initOutput()
        {
                byteOutput = new ByteArrayOutputStream();
                output = new DataOutputStream(byteOutput);
        }
 
    public void sendAllUser(byte[] bytes) throws Exception
        {
                for(Iterator<User> it = userMap.values().iterator(); it.hasNext();)
                {
                        sendMessage(it.next().getSocket(),bytes);
                }
        }
 
    public void sendMessage(Socket socket,byte[] bytes) throws Exception
        {
                DataOutputStream dataOutput = new DataOutputStream(socket.getOutputStream());
                dataOutput.write(bytes);
                dataOutput.flush();
        }
 
    public short readShort()throws IOException{
          byte[] buf=new byte[2];
          input.read(buf);
          return ConvertType.getShort(buf,true);
    }
 
    public int readInt()throws IOException{
          byte[] buf=new byte[4];
          input.read(buf);
          return ConvertType.getInt(buf, true);
    }
 
    public long readLong()throws IOException{
          byte[] buf=new byte[8];
          input.read(buf);
          return ConvertType.getLong(buf, true);
    }
 
   public float readFloat()throws IOException{
          byte[] buf=new byte[4];
          input.read(buf);
          return ConvertType.getFloat(buf, true);
    }
 
    public String readString()throws IOException{
          int length=readInt();
          byte[] buf=new byte[length];
          input.read(buf);
          return new String(buf);
    }
 
 
 
    public void run(){
        try{
            input = new DataInputStream(socket.getInputStream()) ;
            while (true){
                int cmd=0;
                cmd=readInt();
                System.out.println("命令号:"+cmd);
                if(cmd==ERROR){   //收空包
                    userMap.remove(user.getName());
                    Message msg=new Message();
                    msg.writeString(user.getName()+" 离开");
                    System.out.println(user.getName()+" 离开");
                    try{
                         sendAllUser(msg.getBuff().array());
                    }catch (Exception ex){
                         System.out.println("sendAllUserErr: "+ex.toString());
                     }
                    break;
                }
                switch (cmd){
                    case LOGIN:
                        System.out.println("读取用户名");
                        String userName = readString();
                        user = new User();
                        user.setName(userName);
                        user.setSocket(socket);
                        System.out.println(userName);
                        if(userMap.containsKey(userName)) {
                            Message msg=new Message();
                            msg.writeString("昵称重复");
                                                        sendMessage(socket,msg.getBuff().array());
                            msg.clear();
                            msg=null;
                        }else{
                            System.out.println("有新用户进入:" + userName);
                                                        userMap.put(userName, user);
                                                        initOutput();
                            Message msg=new Message();
                            msg.writeString("连接成功");
                                                        sendMessage(socket,msg.getBuff().array());
                            msg.clear();
                            msg=null;
                        }
                        break;
                }
            }
        }catch (Exception e){
             e.printStackTrace();
             userMap.remove(user.getName());
             Message msg=new Message();
             msg.writeString(user.getName()+" 离开");
            System.out.println(user.getName()+" 离开");
            try{
                sendAllUser(msg.getBuff().array());
            }catch (Exception ex){
                System.out.println("sendAllUserErr: "+ex.toString());
            }
 
        }
    }
}




package com.unity.socket;
 
import java.nio.ByteBuffer;
 
import com.unity.socket.ConvertType;
 
public class Message {
    private ByteBuffer buf;
    public Message(){
        buf=ByteBuffer.allocate(0);
    }
 
    public ByteBuffer getBuff(){
        return  buf;
    }
 
    public void clear(){
        buf.clear();
    }
 
    public void addSize(int len){
        ByteBuffer tmpbuf=ByteBuffer.allocate(buf.capacity()+len);
        buf=null;
        buf=tmpbuf;
    }
 
    public void writeByte(byte b){
       addSize(1);
       buf.put(b);
    }
 
    public void write(byte[] b){
        addSize(b.length);
        buf.put(b);
    }
 
     public void writeShort(short b){
        addSize(2);
        buf.put(ConvertType.getBytes(b,true));
    }
 
    public void writeInt(int b){
        addSize(4);
        buf.put(ConvertType.getBytes(b,true));
    }
 
     public void writeLong(long b){
        addSize(8);
        buf.put(ConvertType.getBytes(b,true));
    }
 
    public void writeFloat(float b){
        addSize(4);
        buf.put(ConvertType.getBytes(b,true)) ;
    }
 
    public void writeString(String s){
        byte[] b= new byte[200];
        b=s.getBytes();
        addSize(4+b.length);
        buf.put(ConvertType.getBytes(b.length,true));
        buf.put(s.getBytes());
    }
}




package com.unity.socket;
 
public class ConvertType
{
        public ConvertType()
        {
                
        }
 
    public final static byte[] getBytes(float s,boolean asc){
        int buf=(int)(s*100);
        return getBytes(buf,asc);
    }
 
     public final static float getFloat(byte[] buf,boolean asc){
        int i=getInt(buf,asc);
        float s=(float)i;
        return s/100;
    }
 
        public final static byte[] getBytes(short s, boolean asc)
        {
            byte[] buf = new byte[2];
            if (asc)
            {
                    for (int i = buf.length - 1; i >= 0; i--)
                    {      
                            buf[i] = (byte) (s & 0x00ff);
                        s >>= 8;
                     }
            }
            else
            {
                    for (int i = 0; i < buf.length; i++)
                    {
           
                        buf[i] = (byte) (s & 0x00ff);
                        s >>= 8;
                    }
            }
            return buf;
          }
          public final static byte[] getBytes(int s, boolean asc) {
            byte[] buf = new byte[4];
            if (asc)
              for (int i = buf.length - 1; i >= 0; i--) {
                buf[i] = (byte) (s & 0x000000ff);
                s >>= 8;
              }
            else
              for (int i = 0; i < buf.length; i++) {
                buf[i] = (byte) (s & 0x000000ff);
                s >>= 8;
              }
            return buf;
          }
          public final static byte[] getBytes(long s, boolean asc) {
            byte[] buf = new byte[8];
            if (asc)
              for (int i = buf.length - 1; i >= 0; i--) {
                buf[i] = (byte) (s & 0x00000000000000ff);
                s >>= 8;
              }
            else
              for (int i = 0; i < buf.length; i++) {
                buf[i] = (byte) (s & 0x00000000000000ff);
                s >>= 8;
              }
            return buf;
          }
          public final static short getShort(byte[] buf, boolean asc)
          {
                    if (buf == null)
                    {
                      throw new IllegalArgumentException("byte array is null!");
                    }
                    if (buf.length > 2)
                    {
                      throw new IllegalArgumentException("byte array size > 2 !");
                    }
                    short r = 0;
                    if (!asc)
                      for (int i = buf.length - 1; i >= 0; i--) {
                        r <<= 8;
                        r |= (buf[i] & 0x00ff);
                      }
                    else
                      for (int i = 0; i < buf.length; i++) {
                        r <<= 8;
                        r |= (buf[i] & 0x00ff);
                      }
                    return r;
          }
          public final static int getInt(byte[] buf, boolean asc) {
            if (buf == null) {
              throw new IllegalArgumentException("byte array is null!");
            }
            if (buf.length > 4) {
              throw new IllegalArgumentException("byte array size > 4 !");
            }
            int r = 0;
            if (!asc)
              for (int i = buf.length - 1; i >= 0; i--) {
                r <<= 8;
                r |= (buf[i] & 0x000000ff);
              }
            else
              for (int i = 0; i < buf.length; i++) {
                r <<= 8;
                r |= (buf[i] & 0x000000ff);
              }
            return r;
          }
          public final static long getLong(byte[] buf, boolean asc) {
            if (buf == null) {
              throw new IllegalArgumentException("byte array is null!");
            }
            if (buf.length > 8) {
              throw new IllegalArgumentException("byte array size > 8 !");
            }
            long r = 0;
            if (!asc)
              for (int i = buf.length - 1; i >= 0; i--) {
                r <<= 8;
                r |= (buf[i] & 0x00000000000000ff);
              }
            else
              for (int i = 0; i < buf.length; i++) {
                r <<= 8;
                r |= (buf[i] & 0x00000000000000ff);
              }
            return r;
      }
        
}





ObsessionLi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
unity简单的聊天socket编程
MaxLykoS的博客
05-21 2485
最近开始自学socket编程，从网上找不到好的教程，索性搬了个梯只， 刚开始学习，水平有限，见谅 窗口布局 Asset 这里我们既当Server也当Client，所以把两个代码都加载上，放到Server这个空GameObject上 这里聊天信息弹出的思路是在chatWindows上加上 然后接受到聊天信息之后将data放到asset下的prefab里实例化...
Unity Socket
shanshui21的博客
12-10 580
服务器 端using System; using System.Collections.Generic; using System.Linq; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading.Tasks; namespace SocketSever { class
Unity——Socket
m0_51743362的博客
05-23 1757
Socket套接字的作用 它是C#提供给我们用于网络通信的一个类（在其他语言当中也有对应的Socket类） 类名：Socket 命名空间：using System.Net.Sockets Socket套接字是支持TCP/IP网络通信的基本操作单位 一个套接字对象包含 1.本机的IP地址和端口 2.对方主机的IP地址和端口 ...
【Unity Socket】Unity Socket TCP网络编程基础
最新发布
zhoutao2333的博客
04-03 1136
【代码】【Unity Socket】Unity Socket TCP网络编程基础。
unity Socket
qq_40467437的博客
08-19 271
将服务器与客户端用socket连接后，先将数据转换成字节数组，再将数据进行封包，发送给服务器，服务器接收到的是封装后的字节数组，将字节数组读到流中，按照封包协议读取数据，完成数据的收发操作。...
socket.io-client-unity3d：Unity3D的socket.io-Client，与socket.io v1.x兼容
02-04
Socket.IO-客户端-Unity3D 产品特点 Unity3D的Socket.IO客户端，与Socket.IO v1.0及更高版本兼容。 （当前不支持Socket.IO V2。） Socket.io是开源实时应用程序框架。 Socket.io组页面： : 版本控制 Socket.IO-...
unity3d websocket 客户端库 socket.io v3 v4
07-31
unity3d商城付费资源，用于实现websocket客户端，有服务端范例代码
SuperSocketClient.U3D:通过源代码将SuperSocket.ClientEngine与Unity3D集成。在Unity3D 5.4.2f2上传递-Unity3d source code
03-25
将SuperSocket.ClientEngine集成到Unity3D。 做一些样品。 通过了Unity3D 5.4.2f2 参考（目录-带地址的库） ProtoBase- Commit:5fcc925ca72b67a528ad1fd72611f9c37effb214 ClientEngine- Commit: d16adc1779c...
Unity3D中的Socket通信2
08-08
在Unity3D中进行Socket通信是开发网络游戏或实时交互应用时不可或缺的一部分。Socket通信允许Unity3D客户端与服务器之间建立连接，发送和接收数据。在本文中，我们将深入探讨Unity3D中的Socket通信，主要基于给出的...
Unity3D教程：学习Socket(一)1
08-08
在Unity3D中，Socket编程主要用于实现游戏中的网络通信，例如玩家之间的交互、游戏状态同步等。本教程主要讲解了如何使用Socket进行TCP协议的通信，分为服务端（Server）和客户端（Client）两部分。 首先，我们来看...
unity WebSocket
07-13
WebSocket Unity 和后端交互 实现类似 Socket 的双向交互 欢迎拿去琢磨 修改Url 就可用
unity Socket通讯
01-24
里面有一个客户端类 一个服务器类 有个ip配置类 设置好打开两个unity就可以创建连接
Unity C# socket客户端框架
03-22
应用于unity的C# Socket客户端框架，包含完整的通用逻辑与常见的异常处理，可供新人学习使用。该代码并不能够直接运行，仅供阅读和参考。
简单的基于Unity3D的Socket通讯
09-06
简单的基于Unity的客户端连接服务器端，相互发送一次数据，文档描述位于http://blog.sina.com.cn/s/blog_1322690230102y3l4.html
Unity Socket 初级入门
qq_43016637的博客
02-02 823
在unity运行socket类收发消息的踩雷
【Unity】Socket网络通信（TCP） - 实现简单的多人聊天功能
weixin_43453797的博客
10-14 7979
unity实现非常简单的多人聊天功能，内含工程文件下载地址，免积分下载！
Unity3D入门二：Socket初探
热门推荐
03-30 1万+
这几天研究了下Socket交互。     通过网上的资料做了有关Socket的第一个Demo，虽然不是很成熟，但个人感觉已经相对比较完整了。各类型数据的传输接受都有，其中也做了float类型的（因为我感觉做Unity应该用的着）。     功能方面，为了测试多用户交互，我在Demo上开启了4个Socket 4个线程接受数据。实现了服务端通知用户进入 离开功能。     真机上，需要加上字库，
Unity 使用 Socket 进行通信(画面传输)
weixin_55201233的博客
03-07 680
中间遇到一个问题就是，在收到客户端的传过来的文本信息时(就是当前显示的图片名)，去进行对UI的操作(客户端通过文件名加载图片)，Unity就假死了，个人理解好像是因为这个线程在通信，这时候对UI的操作就阻塞了，要放到外部主线程去调用。所以这里有点乱，有懂的大佬希望能给解释一下。然后我用的是UnityWebRequest请求(也可以使用WWW类请求数据)，在Awake启用协程获取文本中的ip地址，然后同步执行向服务端发送连接，导致ip地址还没拿到一直为空，所以后面就将连接放在Start中去开启了。
Unity Socket TCP
AGroupOfRuffian的博客
12-07 431
[csharp] view plain copy using UnityEngine;   using System.Collections;   using System.Collections.Generic;   using System.Net.Sockets;   using System.Net;   using System.Text;
Unity3D入门：基于Socket的公共聊天室实现详解
此教程对于想要了解Unity3D中的网络通信或者初步接触网游开发的开发者来说，是一个实用且具有指导意义的入门指南。通过实践这个项目，学习者将能掌握基本的网络编程技术，并将其应用于实际的游戏场景中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值