关于修改游戏配置这点，如果pc还好

但是在移动端，比较麻烦，比如游戏换ip地址了，可能需要重新打包了

那能不能动态修改，这里有个思路

以udp举例

在客户端里面写一个udp服务，在游戏第一界面打开，比如在登录界面

那么切换这个界面，就可以把这个服务给关掉了。消耗也不大

写个udp的客户端，给游戏客户端的udp服务发消息

客户端根据收到的消息来修改自己的配置，保存于本地

下次启动游戏，那么配置就生效了

其实就是相当于把客户端写了一个服务器功能

让2者处于同一网络下，就可以连接了，比如wifi下

 

server

  1. using UnityEngine;
  2. using System.Collections;
  3. //引入库
  4. using System.Net;
  5. using System.Net.Sockets;
  6. using System.Text;
  7. using System.Threading;
  8.  
  9. public class UdpServer:MonoBehaviour
  10. {
  11.     //以下默认都是私有的成员
  12.     Socket socket; //目标socket
  13.     EndPoint clientEnd; //客户端
  14.     IPEndPoint ipEnd; //侦听端口
  15.     string recvStr; //接收的字符串
  16.     string sendStr; //发送的字符串
  17.     byte[] recvData=new byte[1024]; //接收的数据，必须为字节
  18.     byte[] sendData=new byte[1024]; //发送的数据，必须为字节
  19.     int recvLen; //接收的数据长度
  20.     Thread connectThread; //连接线程
  21.  
  22.    
  23.     //初始化
  24.     void InitSocket()
  25.     {
  26.         //定义侦听端口,侦听任何IP
  27.         ipEnd=new IPEndPoint(IPAddress.Any,8001);
  28.         //定义套接字类型,在主线程中定义
  29.         socket=new Socket(AddressFamily.InterNetwork,SocketType.Dgram,ProtocolType.Udp);
  30.         //服务端需要绑定ip
  31.         socket.Bind(ipEnd);
  32.         //定义客户端
  33.         IPEndPoint sender=new IPEndPoint(IPAddress.Any,0);
  34.         clientEnd=(EndPoint)sender;
  35.         print("waiting for UDP dgram");
  36.  
  37.         //开启一个线程连接，必须的，否则主线程卡死
  38.         connectThread=new Thread(new ThreadStart(SocketReceive));
  39.         connectThread.Start();
  40.     }
  41.  
  42.     void SocketSend(string sendStr)
  43.     {
  44.         //清空发送缓存
  45.         sendData=new byte[1024];
  46.         //数据类型转换
  47.         sendData=Encoding.ASCII.GetBytes(sendStr);
  48.         //发送给指定客户端
  49.         socket.SendTo(sendData,sendData.Length,SocketFlags.None,clientEnd);
  50.     }
  51.  
  52.     //服务器接收
  53.     void SocketReceive()
  54.     {
  55.         //进入接收循环
  56.         while(true)
  57.         {
  58.             //对data清零
  59.             recvData=new byte[1024];
  60.             //获取客户端，获取客户端数据，用引用给客户端赋值
  61.             recvLen=socket.ReceiveFrom(recvData,ref clientEnd);
  62.             print("message from: "+clientEnd.ToString()); //打印客户端信息
  63.             //输出接收到的数据
  64.             recvStr=Encoding.ASCII.GetString(recvData,0,recvLen);
  65.             print(recvStr);
  66.             //将接收到的数据经过处理再发送出去
  67.             sendStr="From Server: "+recvStr;
  68.             SocketSend(sendStr);
  69.         }
  70.     }
  71.  
  72.     //连接关闭
  73.     void SocketQuit()
  74.     {
  75.         //关闭线程
  76.         if(connectThread!=null)
  77.         {
  78.             connectThread.Interrupt();
  79.             connectThread.Abort();
  80.         }
  81.         //最后关闭socket
  82.         if(socket!=null)
  83.             socket.Close();
  84.         print("disconnect");
  85.     }
  86.  
  87.     // Use this for initialization
  88.     void Start()
  89.     {
  90.         InitSocket(); //在这里初始化server
  91.     }
  92.  
  93.  
  94.     // Update is called once per frame
  95.     void Update()
  96.     {
  97.  
  98.     }
  99.  
  100.     void OnApplicationQuit()
  101.     {
  102.         SocketQuit();
  103.     }
  104. }

 

client

  1. using UnityEngine;
  2. using System.Collections;
  3. //引入库
  4. using System.Net;
  5. using System.Net.Sockets;
  6. using System.Text;
  7. using System.Threading;
  8.  
  9. public class UdpClient:MonoBehaviour
  10. {
  11.     string editString="hello wolrd"; //编辑框文字
  12.  
  13.     //以下默认都是私有的成员
  14.     Socket socket; //目标socket
  15.     EndPoint serverEnd; //服务端
  16.     IPEndPoint ipEnd; //服务端端口
  17.     string recvStr; //接收的字符串
  18.     string sendStr; //发送的字符串
  19.     byte[] recvData=new byte[1024]; //接收的数据，必须为字节
  20.     byte[] sendData=new byte[1024]; //发送的数据，必须为字节
  21.     int recvLen; //接收的数据长度
  22.     Thread connectThread; //连接线程
  23.  
  24.     //初始化
  25.     void InitSocket()
  26.     {
  27.         //定义连接的服务器ip和端口，可以是本机ip，局域网，互联网
  28.         ipEnd=new IPEndPoint(IPAddress.Parse("127.0.0.1"),8001); 
  29.         //定义套接字类型,在主线程中定义
  30.         socket=new Socket(AddressFamily.InterNetwork,SocketType.Dgram,ProtocolType.Udp);
  31.         //定义服务端
  32.         IPEndPoint sender=new IPEndPoint(IPAddress.Any,0);
  33.         serverEnd=(EndPoint)sender;
  34.         print("waiting for sending UDP dgram");
  35.  
  36.         //建立初始连接，这句非常重要，第一次连接初始化了serverEnd后面才能收到消息
  37.         SocketSend("hello");
  38.  
  39.         //开启一个线程连接，必须的，否则主线程卡死
  40.         connectThread=new Thread(new ThreadStart(SocketReceive));
  41.         connectThread.Start();
  42.     }
  43.  
  44.     void SocketSend(string sendStr)
  45.     {
  46.         //清空发送缓存
  47.         sendData=new byte[1024];
  48.         //数据类型转换
  49.         sendData=Encoding.ASCII.GetBytes(sendStr);
  50.         //发送给指定服务端
  51.         socket.SendTo(sendData,sendData.Length,SocketFlags.None,ipEnd);
  52.     }
  53.  
  54.     //服务器接收
  55.     void SocketReceive()
  56.     {
  57.         //进入接收循环
  58.         while(true)
  59.         {
  60.             //对data清零
  61.             recvData=new byte[1024];
  62.             //获取客户端，获取服务端端数据，用引用给服务端赋值，实际上服务端已经定义好并不需要赋值
  63.             recvLen=socket.ReceiveFrom(recvData,ref serverEnd);
  64.             print("message from: "+serverEnd.ToString()); //打印服务端信息
  65.             //输出接收到的数据
  66.             recvStr=Encoding.ASCII.GetString(recvData,0,recvLen);
  67.             print(recvStr);
  68.         }
  69.     }
  70.  
  71.     //连接关闭
  72.     void SocketQuit()
  73.     {
  74.         //关闭线程
  75.         if(connectThread!=null)
  76.         {
  77.             connectThread.Interrupt();
  78.             connectThread.Abort();
  79.         }
  80.         //最后关闭socket
  81.         if(socket!=null)
  82.             socket.Close();
  83.     }
  84.  
  85.     // Use this for initialization
  86.     void Start()
  87.     {
  88.         InitSocket(); //在这里初始化
  89.     }
  90.  
  91.     void OnGUI()
  92.     {
  93.         editString=GUI.TextField(new Rect(10,10,100,20),editString);
  94.         if(GUI.Button(new Rect(10,30,60,20),"send"))
  95.             SocketSend(editString);
  96.     }
  97.  
  98.     // Update is called once per frame
  99.     void Update()
  100.     {
  101.  
  102.     }
  103.  
  104.     void OnApplicationQuit()
  105.     {
  106.         SocketQuit();
  107.     }
  108. }

 

版权声明：本文为sanyejun原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/sanyejun/p/10065253.html