WeaveSocket框架-Unity太空大战游戏-服务端-1

最新推荐文章于 2023-04-13 21:18:03 发布
最新推荐文章于 2023-04-13 21:18:03 发布
阅读量1k 收藏 1
点赞数
分类专栏： Unity3D Socket编程 文章标签： socket 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/superlinmeng/article/details/78631751
版权

WeaveSocket框架-Unity太空大战游戏-服务端-1（换成Markdown富文本重写，之前排版有点乱）

服务端项目结构

这里写图片描述

主要技术架构

Socket框架【WeaveSocket】 及其扩展项目
https://gitee.com/dreamsfly900/universal-Data-Communication-System-for-windows/
数据库【LiteDB】(3.1.4.0)
http://www.litedb.org/
界面UI【WPF】(.Net4.5)

服务端启动类为MyTCPCloud里面的WeaveTCPcloud这个类，用于根据传入的参数，启动服务器监听Socket请求

代码如下：

using MyTcpCommandLibrary;
using System;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Reflection;
using System.Xml;
using WeaveBase;
using WeaveSocketServer;
namespace MyTCPCloud
{
    public class WeaveTCPcloud : IWeaveUniversal
    {
        public event WeaveLogDelegate WeaveLogEvent;

        public event WeaveServerReceiveSocketMessageCallBack WeaveServerReceiveSocketMessageCallBackEvent;


    public event WeaveServerDeleteSocketCallBack WeaveServerDeleteSocketCallBackEvent;


    public event WeaveServerUpdateSocketCallBack WeaveServerUpdateSocketCallBackEvent;


    public event WeaveServerReceiveOnLineUnityPlayerMessageCallBack WeaveServerReceiveOnLineUnityPlayerMessageCallBackEvent;


    public event WeaveServerGetUnityPlayerOnLineCallBack WeaveServerGetUnityPlayerOnLineCallBackEvent;

    public event WeaveServerGetUnityPlayerOffLineCallBack WeaveServerGetUnityPlayerOffLineCallBackEvent;


        //public XmlDocument xml
        //{
        //    get;set;
        //}

        public List<WeaveTCPCommandItem> weaveTCPCommandItems
        {
            get
            {
                return _weaveTCPCommandItems;
            }

            set
            {
                _weaveTCPCommandItems = value;
            }
        }

        public WeaveTable weaveTable
        {
            get
            {
                return _weaveTable;
            }

            set
            {
                _weaveTable = value;
            }
        }

        public List<WeaveOnLine> weaveOnline
        {
            get
            {
                return _weaveOnline;
            }

            set
            {
                _weaveOnline = value;
            }
        }

        public List<UnityPlayerOnClient> unityPlayerOnClientList
        {
            get
            {
                return _unityPlayerOnClientList;
            }

            set
            {
                _unityPlayerOnClientList = value;
            }
        }

       // public IWeaveTcpBase P2Server
         public WeaveP2Server P2Server
        {
            get;set;
        }

        public WeaveTcpToken TcpToken
        {
            get
            {
                return _TcpToken;
            }

            set
            {
                _TcpToken = value;
            }
        }

        List<WeaveTCPCommandItem> _weaveTCPCommandItems = new List<WeaveTCPCommandItem>();

        WeaveTable _weaveTable = new WeaveTable();

        List<WeaveOnLine> _weaveOnline = new List<WeaveOnLine>();


       WeaveTcpToken _TcpToken = new WeaveTcpToken();

        //我写的方法
        List<UnityPlayerOnClient> _unityPlayerOnClientList = new List<UnityPlayerOnClient>();




        public bool Run(WevaeSocketSession myI)
        {
            //ReloadFlies();
            AddMyTcpCommandLibrary();


            weaveTable.Add("onlinetoken", weaveOnline);//初始化一个队列，记录在线人员的token
            if (WeaveLogEvent != null)
                WeaveLogEvent("连接", "连接启动成功");
            return true;
        }
        /// <summary>
        /// 读取WeavePortTypeEnum类型后，初始化 new WeaveP2Server("127.0.0.1"),并添加端口;
        /// </summary>
        /// <param name="WeaveServerPort"></param>
        public void StartServer(WeaveServerPort _ServerPort)
        {
              P2Server = new WeaveP2Server("127.0.0.1");

              P2Server.waveReceiveEvent += P2ServerReceiveHander;
               P2Server.weaveUpdateSocketListEvent += P2ServerUpdateSocketHander;
               P2Server.weaveDeleteSocketListEvent += P2ServerDeleteSocketHander;
               P2Server.Start( _ServerPort.Port  );
               TcpToken.PortType = _ServerPort.PortType;
               TcpToken.P2Server = P2Server;
              TcpToken.IsToken = _ServerPort.IsToken;
               TcpToken.WPTE = _ServerPort.PortType;

        }


        public void AddMyTcpCommandLibrary()
        {
            try
            {
                LoginManageCommand loginCmd = new LoginManageCommand();
                loginCmd.ServerLoginOKEvent += OnUnityPlayerLoginOK;
                AddCmdWorkItems(loginCmd);

                AddCmdWorkItems(new GameScoreCommand());

                AddCmdWorkItems(new ClientDisConnectedCommand());



            }
            catch
            {

            }
        }

        private void OnUnityPlayerLoginOK(string _u, Socket _socket)
        {
            WeaveOnLine onLineSocket = weaveOnline.Find(w => w.Socket == _socket);

            // throw new NotImplementedException();
            UnityPlayerOnClient gamer = new UnityPlayerOnClient()
            {
                UserName = _u,
                isLogin = true,
                 Name = onLineSocket.Name,
                  Obj =onLineSocket.Obj,
                    Socket = _socket,
                     Token = onLineSocket.Token
            };

            WeaveServerGetUnityPlayerOnLineCallBackEvent(gamer);

        }

        public bool CheckIsOnLinePlayerMessage(Socket _socket)
        {
            WeaveOnLine onLineSocket = weaveOnline.Find(w => w.Socket == _socket);
            if (unityPlayerOnClientList.Count == 0)
                return false;
            else
            {
                UnityPlayerOnClient player = unityPlayerOnClientList.Find(u => u.Name == onLineSocket.Name);
                if (player != null)
                    return true;
                else
                    return false;
            }

        }

        public void Check_ReceiveMessageCallBackEvent(byte command, string data, Socket _socket)
        {
            if(CheckIsOnLinePlayerMessage(_socket))
            {
                UnityPlayerOnClient player = unityPlayerOnClientList.Find(u => u.Socket == _socket);
                WeaveServerReceiveOnLineUnityPlayerMessageCallBackEvent(command, data, player);
            }
            else
            {
                WeaveOnLine onLine = weaveOnline.Find(w => w.Socket == _socket);
                WeaveServerReceiveSocketMessageCallBackEvent( command, data, onLine);
            }
        }


        public void AddCmdWorkItems(WeaveTCPCommand cmd)
        {
            cmd.SetGlobalQueueTable(weaveTable, TcpToken);
            WeaveTCPCommandItem cmdItem = new WeaveTCPCommandItem();
            // Ic.SetGlobalQueueTable(weaveTable, TcpTokenList);
            cmdItem.WeaveTcpCmd = cmd;
            cmdItem.CmdName = cmd.Getcommand();
            GetAttributeInfo(cmd, cmd.GetType(), cmd);
            weaveTCPCommandItems.Add(cmdItem);
        }


        public void GetAttributeInfo(WeaveTCPCommand Ic, Type t, object obj)
        {
            foreach (MethodInfo mi in t.GetMethods())
            {
                InstallFunAttribute myattribute = (InstallFunAttribute)Attribute.GetCustomAttribute(mi, typeof(InstallFunAttribute));
                if (myattribute == null)
                {
                }
                else
                {
                    if (myattribute.Dtu)
                    {
                        Delegate del = Delegate.CreateDelegate(typeof(WeaveRequestDataDtuDelegate), obj, mi, true);
                        Ic.Bm.AddListen(mi.Name, del as WeaveRequestDataDtuDelegate, myattribute.Type, true);
                    }
                    else
                    {
                        Delegate del = Delegate.CreateDelegate(typeof(WeaveRequestDataDelegate), obj, mi, true);
                        Ic.Bm.AddListen(mi.Name, del as WeaveRequestDataDelegate, myattribute.Type);
                    }
                }
            }
        }


        void P2ServerUpdateSocketHander(System.Net.Sockets.Socket soc)
        {
            CallWeaveServerUpdateSocketCallBackEvent(soc);


            CallWeaveTCPCommandClassUpdateSocketEvent(soc);


            WeaveTcpToken token = TcpToken;
            {
                if (token.IsToken)
                {
                    //生成一个token,后缀带随机数
                    string Token = DateTime.Now.ToString("yyyyMMddHHmmssfff") + new Random().Next(1000, 9999);// EncryptDES(clientipe.Address.ToString() + "|" + DateTime.Now.ToString(), "lllssscc");
                    if (token.P2Server.Port == ((System.Net.IPEndPoint)soc.LocalEndPoint).Port)
                    {
                        //向客户端发送生成的token
                        bool sendok = false;
                        if (token.PortType == WeavePortTypeEnum.Bytes)
                            sendok = token.P2Server.Send(soc, 0xff, token.BytesDataparsing.Get_ByteBystring("token|" + Token + ""));
                        else
                            sendok = token.P2Server.Send(soc, 0xff, "token|" + Token + "");


                        #region  if(sendok) 如果发送token成功
                        if (sendok)
                        {
                            WeaveOnLine onLine = CreatWeaveOnLine(Token, soc);

                            AddWeaveOnLine(onLine);



                            ForeachWeaveExecuteRuncommandMethod(onLine);

                            return;
                        }
                        #endregion
                    }
                }
                else
                {
                    WeaveOnLine online = CreatWeaveOnLine(soc);
                    weaveOnline.Add(online);



                }

            }
        }


        void P2ServerDeleteSocketHander(System.Net.Sockets.Socket soc)
        {


            CallWeaveServerDeleteSocketCallBackEvent(soc);

            // WeaveServerGetUnityPlayerOffLineCallBackEvent()
            CallWeaveServerGetUnityPlayerOffLineCallBackEvent(soc);

            CallWeaveTCPCommandClassDeleteSocketEvent(soc);

            WeaveExecuteRuncommandMethod_Tokenout_RemoveWeaveOnline(soc);

        }


        void P2ServerReceiveHander(byte command, string data, System.Net.Sockets.Socket soc)
        {
            //这里待定判定，，是登陆用户的 还是，，，原始Socket发过来的,,来判定执行不同的事件
            //普通Socket数据接收事件，还是 登陆的Unity客户端发过来的数据，进入数据接收处理事件
            Check_ReceiveMessageCallBackEvent(command, data, soc);
            //客户端 登陆 事件要 在这里执行

            //客户端 登陆的 Unity用户发来的消息 会 在这里执行
            if(command == (byte)CommandEnum.ClientSendDisConnected)
            {
                P2Server.CliendSendDisConnectedEvent(soc);


                return;
            }

            try
            {
                if (command == 0xff)
                {
                    //如果是网关command 发过来的 命名，那么执行下面的
                    WeaveExecuteRuncommandMethod(command, data, soc);

                    try
                    {
                        string[] temp = data.Split('|');
                        if (temp[0] == "in")
                        {

                            WeaveAddOnLineTokenIn(temp[1] , soc);
                            return;
                        }
                        else if (temp[0] == "Restart")
                        {
                            RestartWeaveOnLineSocket(temp[1], soc);

                        }
                        else if (temp[0] == "out")
                        {
                            WeaveExecuteTokenoutMethod(temp[1]);
                            ////移出onlinetoken
                        }
                    }
                    catch
                    {
                    }
                    return;
                }

                else
                    WeaveExecuteRunMethod(command, data, soc);
            }
            catch
            {
                return;
            }
        }

        public void CallWeaveServerUpdateSocketCallBackEvent(Socket _soc)
        {
            WeaveOnLine online = weaveOnline.Find(s => s.Socket == _soc);
            if (online == null)
            {
                WeaveOnLine temponline = CreatWeaveOnLine(_soc);
                WeaveServerUpdateSocketCallBackEvent(temponline);
            }
            else
            {
                WeaveServerUpdateSocketCallBackEvent(online);
            }

        }

        public void CallWeaveServerDeleteSocketCallBackEvent(Socket _soc)
        {
            WeaveOnLine online = weaveOnline.Find(s => s.Socket == _soc);
            if(online !=null)
                WeaveServerDeleteSocketCallBackEvent(online);
        }


        public void CallWeaveServerGetUnityPlayerOffLineCallBackEvent(Socket _soc)
        {
            UnityPlayerOnClient unitygm = unityPlayerOnClientList.Find(p => p.Socket == _soc);

            WeaveServerGetUnityPlayerOffLineCallBackEvent(unitygm);
        }


        public void WeaveExecuteRuncommandMethod_Tokenout_RemoveWeaveOnline(Socket _soc)
        {
            try
            {
                int count = weaveOnline.Count;
                WeaveOnLine[] ols = new WeaveOnLine[count];
                weaveOnline.CopyTo(0, ols, 0, count);
                foreach (WeaveOnLine ol in ols)
                {
                    if (ol.Socket.Equals(_soc))
                    {
                        foreach (WeaveTCPCommandItem weaveTCPCommandItem in weaveTCPCommandItems)
                        {
                            try
                            {
                                WeaveExecuteRuncommandMethod(0xff, "out|" + ol.Token, ol.Socket);
                                weaveTCPCommandItem.WeaveTcpCmd.Tokenout(ol);
                            }
                            catch (Exception ex)
                            {
                                if (WeaveLogEvent != null)
                                    WeaveLogEvent("Tokenout", ex.Message);
                            }
                        }
                        weaveOnline.Remove(ol);
                        return;
                    }
                }
            }
            catch { }
        }

        public void  CallWeaveTCPCommandClassDeleteSocketEvent(Socket soc)
        {
            try
            {
                int count = weaveTCPCommandItems.Count;
                WeaveTCPCommandItem[] commandlist = new WeaveTCPCommandItem[count];
                weaveTCPCommandItems.CopyTo(0, commandlist, 0, count);
                foreach (WeaveTCPCommandItem weaveTCPCommandItem in commandlist)
                {
                    try
                    {
                        weaveTCPCommandItem.WeaveTcpCmd.WeaveDeleteSocketEvent(soc);
                    }
                    catch (Exception ex)
                    {
                        if (WeaveLogEvent != null)
                            WeaveLogEvent("EventDeleteConnSoc", ex.Message);
                    }
                }
            }
            catch { }
        }


        public void CallWeaveTCPCommandClassUpdateSocketEvent(Socket soc)
        {
            try
            {
                int count = weaveTCPCommandItems.Count;
                WeaveTCPCommandItem[] commandlist = new WeaveTCPCommandItem[count];
                weaveTCPCommandItems.CopyTo(0, commandlist, 0, count);
                foreach (WeaveTCPCommandItem weaveTCPCommandItem in commandlist)
                {
                    try
                    {
                        weaveTCPCommandItem.WeaveTcpCmd.WeaveUpdateSocketEvent(soc);
                    }
                    catch (Exception ex)
                    {
                        if (WeaveLogEvent != null)
                            WeaveLogEvent("EventUpdataConnSoc", ex.Message);
                    }
                }
            }
            catch
            {

            }
        }


        public void ForeachWeaveExecuteRuncommandMethod(WeaveOnLine onLine)
        {


            foreach (WeaveTCPCommandItem cmdItem in weaveTCPCommandItems)
            {
                try
                {
                    WeaveExecuteRuncommandMethod(0xff, "in|" + onLine.Token, onLine.Socket);
                    cmdItem.WeaveTcpCmd.TokenIn(onLine);
                }
                catch (Exception ex)
                {
                    if (WeaveLogEvent != null)
                        WeaveLogEvent("Tokenin", ex.Message);
                }
            }
        }


        /// <summary>
        /// 执行继承自WeaveTCPCommand类里面的Runcommand方法
        /// </summary>
        /// <param name="command"></param>
        /// <param name="data"></param>
        /// <param name="soc"></param>
        public void WeaveExecuteRuncommandMethod(byte command, string data, System.Net.Sockets.Socket soc)
        {
            foreach (WeaveTCPCommandItem cmd in weaveTCPCommandItems)
            {
                try
                {

                    cmd.WeaveTcpCmd.Runcommand(command, data, soc);
                }
                catch (Exception ex)
                {
                    WeaveLogEvent?.Invoke("receiveevent", ex.Message);
                }
            }
        }


        /// <summary>
        /// 不是0xff这个command发来的...命令
        /// </summary>
        /// <param name="command"></param>
        /// <param name="data"></param>
        /// <param name="soc"></param>
        public void WeaveExecuteRunMethod(byte command, string data, System.Net.Sockets.Socket soc)
        {
            foreach (WeaveTCPCommandItem cmd in weaveTCPCommandItems)
            {
                if (cmd.CmdName == command)
                {
                    try
                    {
                        cmd.WeaveTcpCmd.Run(data, soc);
                        cmd.WeaveTcpCmd.RunBase(data, soc);
                    }
                    catch (Exception ex)
                    {
                        WeaveLogEvent?.Invoke("receiveevent", ex.Message);
                    }
                }
            }
        }

        public void WeaveExecuteTokenoutMethod(string _token)
        {

            ////移出onlinetoken
            int count = weaveOnline.Count;
            WeaveOnLine[] ols = new WeaveOnLine[count];
            weaveOnline.CopyTo(0, ols, 0, count);
            foreach (WeaveOnLine onlinesession in ols)
            {
                if (onlinesession.Token == _token)//temp[1])
                {
                    foreach (WeaveTCPCommandItem cmdItem in weaveTCPCommandItems)
                    {
                        try
                        {
                            cmdItem.WeaveTcpCmd.Tokenout(onlinesession);
                        }
                        catch (Exception ex)
                        {
                            WeaveLogEvent?.Invoke("Tokenout", ex.Message);
                        }
                    }
                    weaveOnline.Remove(onlinesession);
                    return;
                }
            }
        }


        public void RestartWeaveOnLineSocket(string _s , Socket _soc)
        {
            int count = weaveOnline.Count;
            WeaveOnLine[] ols = new WeaveOnLine[count];
            weaveOnline.CopyTo(0, ols, 0, count);
            string IPport = ((System.Net.IPEndPoint)_soc.RemoteEndPoint).Address.ToString() + ":" + _s;// temp[1];
            foreach (WeaveOnLine ol in ols)
            {
                try
                {
                    if (ol.Socket != null)
                    {
                        String IP = ((System.Net.IPEndPoint)ol.Socket.RemoteEndPoint).Address.ToString() + ":" + ((System.Net.IPEndPoint)ol.Socket.RemoteEndPoint).Port;
                        if (IP == IPport)
                        {
                            ol.Socket = _soc;
                        }
                    }
                }
                catch { }
            }
        }

        public void WeaveAddOnLineTokenIn(string _s , Socket soc)
        {
            WeaveOnLine ol = new WeaveOnLine();
            ol.Token = _s;
            ol.Socket = soc;
            weaveOnline.Add(ol);
            foreach (WeaveTCPCommandItem weaveTCPCommandItem in weaveTCPCommandItems)
            {
                try
                {
                    weaveTCPCommandItem.WeaveTcpCmd.TokenIn(ol);
                }
                catch (Exception ex)
                {
                    WeaveLogEvent?.Invoke("Tokenin", ex.Message);
                }
            }
        }


        public WeaveOnLine CreatWeaveOnLine(Socket _socket)
        {
            WeaveOnLine ol = new WeaveOnLine()
            {
                Name = DateTime.Now.ToString("yyyyMMddHHmmssfff"),
                Obj = DateTime.Now.ToString("yyyyMMddHHmmssfff"),
                Socket = _socket,
                Token = DateTime.Now.ToString("yyyyMMddHHmmssfff")

            };

            return ol;
        }

        public WeaveOnLine CreatWeaveOnLine(string _token,Socket _socket)
        {
            WeaveOnLine ol = new WeaveOnLine()
            {
                Name = DateTime.Now.ToString("yyyyMMddHHmmssfff"),
                Obj = DateTime.Now.ToString("yyyyMMddHHmmssfff"),
                Socket = _socket,
                Token = _token

            };

            return ol;
        }


        public UnityPlayerOnClient ConvertWeaveOnlineToUnityPlayerOnClient(WeaveOnLine  wonline)
        {
            UnityPlayerOnClient uplayer = new UnityPlayerOnClient()
            {
                Obj = wonline.Obj,
                Socket = wonline.Socket,
                Token = wonline.Token,
                Name = wonline.Name
            };



            return uplayer;

        }

        public void DeleteUnityPlayerOnClient(Socket osc)
        {
            try
            {
                if (unityPlayerOnClientList.Count > 0)
                    unityPlayerOnClientList.Remove(unityPlayerOnClientList.Find(u => u.Socket == osc));
            }
            catch
            {

            }
        }



        public void AddUnityPlayerClient_CheckSameItem(UnityPlayerOnClient item ,string itemName)
        {
            System.Threading.Thread.Sleep(500);
            lock (this)
            {
                if (unityPlayerOnClientList.Find(i => i.Name == itemName) != null)
                    return;

                else
                    unityPlayerOnClientList.Add(item);
            }
        }

        public void AddWeaveOnLine(WeaveOnLine item)
        {
            WeaveOnLine hasOnline = weaveOnline.Find(w => w.Name == item.Name);
            {
                if (hasOnline != null)
                {
                    weaveOnline.Remove(hasOnline);
                    //添加修改参数后的WeaveOnLine
                    weaveOnline.Add(item);

                }
                else
                {
                    weaveOnline.Add(item);
                }
            }
        }
    }
}

重点说下AddMyTcpCommandLibrary方法

这个方法加载了MyTcpCommandLibrary项目下的几个继承自WeaveTCPCommand的类，用于接收客户端发过来的数据中，对应第一位byte，于它里面的GetCommand()方法返回的 一位byte命名对应

 public class LoginManageCommand  : WeaveTCPCommand
    {

        public override byte Getcommand()
        {

            //此CLASS的实例，代表的指令，指令从0-254，0x9c与0xff为内部指令不能使用。
            //0x01的意思是，只要是客户端发过来的数据第一位byte为0x01，那么会进入本实例进行处理
            //return 0x01;
            return (byte)CommandEnum.ClientSendLoginModel;
        }
         //其它代码 .................   
        [InstallFun("forever")]
        public void CheckLogin(Socket soc, WeaveSession wsession)
        {
            //执行查找数据的操作......等代码

        }
    }

例如客户端调用框架（客户端也需使用框架）的如下方法发送数据

 weaveSocketGameClient.SendRoot<Model>((byte)CommandEnum.ClientSendLoginModel, "CheckLogin", m , 0);

则会进入LoginManageCommand这个类的CheckLogin方法中进行处理

在看前端WPF-UI使用的实例代码，实例化WeaveTCPcloud,传入相关参数，请监听相关事件，启动服务器

简单说一下几个事件
WeaveServerUpdateSocketCallBackEvent 当有Socket连接到服务器的事件
WeaveServerReceiveSocketMessageCallBackEvent 当有数据从远端Socket发送到服务器的事件（这里没有验证Unity3D客户端的状态，属于UnityPlayerOffLine状态，没有上线，数据发来，在这里接收处理）
WeaveServerDeleteSocketCallBackEvent 当有Socket断开连接的事件
WeaveServerGetUnityPlayerOnLineCallBackEvent 当有Socket（已经连上）发送完账号密码，服务器认证了，生成了一个UnityPlayerOnLine对象的的事件，用于确定登陆上线成功后的玩家的身份
WeaveServerGetUnityPlayerOffLineCallBackEvent 当有Socket（已经连上）并已经上限的玩家，退出游戏，断开连接的事件
WeaveServerReceiveOnLineUnityPlayerMessageCallBackEvent 当有数据从远端Socket发送到服务器的事件（这里的数据是由已经登陆成功上线的Unity3D客户端发来的）事件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using WeaveBase;
using System.Net.Sockets;
using MyTCPCloud;
using System.Windows.Threading;

namespace WeavingSocketServerWPF
{
    /// <summary>
    /// MyUnityServer.xaml 的交互逻辑
    /// </summary>
    public partial class MyUnityServer : Window
    {
        public MyUnityServer()
        {
            InitializeComponent();

           // DispatcherFunction();
        }
        /// <summary>
        /// 监听端口列表，，可以选择监听多个端口
        /// </summary>
        WeaveServerPort wserverport = new WeaveServerPort();
        WeaveTCPcloud weaveTCPcloud = new WeaveTCPcloud();

        List<MyListBoxItem> loginedUserList = new List<MyListBoxItem>();

        List<MyListBoxItem> connectedSocketItemList = new List<MyListBoxItem>();
        // DispatcherTimer dispatcherTimer = new DispatcherTimer();

        private void StartListen_button_Click(object sender, RoutedEventArgs e)
        {
            //设置登陆后的用户列表Listbox的数据源
            LoginedUser_listBox.ItemsSource = loginedUserList;
            //设置连接到服务器的Socket列表的Listbox的数据源
            ConnectedSocket_listBox.ItemsSource = connectedSocketItemList;

            WevaeSocketSession mif = new WevaeSocketSession();

            weaveTCPcloud.Run(mif);


            wserverport.IsToken = true;
            wserverport.Port = Convert.ToInt32(Port_textBox.Text);
            wserverport.PortType = WeavePortTypeEnum.Json;

            weaveTCPcloud.StartServer(wserverport);


            weaveTCPcloud.WeaveServerUpdateSocketCallBackEvent += OnWeaveUpdateSocket;

            weaveTCPcloud.WeaveServerReceiveSocketMessageCallBackEvent += OnWeaveReceiveSocketMessage;

            weaveTCPcloud.WeaveServerDeleteSocketCallBackEvent += OnWeaveDeleteSocket;



            weaveTCPcloud.WeaveServerGetUnityPlayerOnLineCallBackEvent += OnWeaveServerGetUnityPlayerOnLineEvent;

            weaveTCPcloud.WeaveServerGetUnityPlayerOffLineCallBackEvent += OnWeaveServerGetUnityPlayerOffLineEvent;

            weaveTCPcloud.WeaveServerReceiveOnLineUnityPlayerMessageCallBackEvent += OnWeaveServerReceiveOnLineUnityPlayerMessageEvent;

            StartListen_button.Content = "正在监听";

            StartListen_button.IsEnabled = false;

        }



        private void OnWeaveServerGetUnityPlayerOnLineEvent(UnityPlayerOnClient gamer)
        {
            //当有用户 账号密码登陆成功的时候
            AddListBoxItemAction(loginedUserList, CopyUnityPlayerOnClientToMyListBoxItem(gamer));
            SetServerReceiveText("Unity登陆后的玩家--触发了一次（OnWeaveServerUpdateUnityPlayerSetOnLineEvent）" + Environment.NewLine);


        }


        private void OnWeaveServerGetUnityPlayerOffLineEvent(UnityPlayerOnClient gamer)
        {

            SetServerReceiveText("Unity玩家下线事件--触发了一次（OnWeaveServerGetUnityPlayerOffLineEvent）" + Environment.NewLine);

        }

        private void OnWeaveServerReceiveOnLineUnityPlayerMessageEvent(byte command, string data, UnityPlayerOnClient gamer)
        {
            // 登陆用户发送过来的数据

            SetServerReceiveText("Unity玩家登陆事件--触发了一次（OnWeaveServerReceiveOnLineUnityPlayerMessageEvent）" + Environment.NewLine);

            WeaveSession ws = Newtonsoft.Json.JsonConvert.DeserializeObject<WeaveSession>( data);

            SetServerReceiveText("收到【"+gamer.UserName+"】发来的数据：  " + ws.Root + Environment.NewLine );

        }


        private void OnWeaveUpdateSocket(WeaveOnLine weaveOnLine)
        {
            SetServerReceiveText("Socket连接--触发了一次（OnWeaveUpdateSocket）" + Environment.NewLine);

            //有 Sokcet客户端连接到服务器的时候，暂未 账号，密码认证状态

            AddListBoxItemAction(connectedSocketItemList, CopyWeaveOnLineToMyListBoxItem(weaveOnLine) );

        }

        private void OnWeaveReceiveSocketMessage(byte command, string data, WeaveOnLine _socket)
        {
            WeaveSession ws = Newtonsoft.Json.JsonConvert.DeserializeObject<WeaveSession>(data);


            SetServerReceiveText("Socket发来数据--触发了一次（OnWeaveReceiveSocketMessage）" + Environment.NewLine);
            SetServerReceiveText("收到的数据为：  " + ws.Root + Environment.NewLine);

        }

        private void OnWeaveDeleteSocket(WeaveOnLine weaveOnLine)
        {
            SetServerReceiveText("Socket断开--退出事件--触发了一次（OnWeaveDeleteSocket）" + Environment.NewLine);

            RemoveListBoxItemAction(connectedSocketItemList, CopyWeaveOnLineToMyListBoxItem(weaveOnLine));

            MyListBoxItem oneItem = loginedUserList.Find(item => item.Ip == weaveOnLine.Socket.RemoteEndPoint.ToString());
            RemoveListBoxItemAction(loginedUserList, oneItem );


        }


        private void StopListen_button_Click(object sender, RoutedEventArgs e)
        {

            weaveTCPcloud.P2Server = null;

            weaveTCPcloud = null;

            Application.Current.Shutdown();
            Environment.Exit(0);// 可以立即中断程序执行并退出
        }

        private void SendMsg_button_Click(object sender, RoutedEventArgs e)
        {

            string serverMsg = InputSendMessage_textBox.Text;
            int unityGamecount = weaveTCPcloud.unityPlayerOnClientList.Count;
            if (string.IsNullOrEmpty(serverMsg) || weaveTCPcloud.weaveOnline.Count==0)
                return;

            WeaveOnLine[] _allWeaveOnLine = new WeaveOnLine[weaveTCPcloud.weaveOnline.Count];

            weaveTCPcloud.weaveOnline.CopyTo(_allWeaveOnLine);

            foreach (WeaveOnLine oneWeaveOnLine in _allWeaveOnLine)
            {
                weaveTCPcloud.P2Server.Send(oneWeaveOnLine.Socket, 0x01, "服务器主动给所有客户端发消息了: " + serverMsg);
            }

           // MessageBox.Show("客户端在线数量："+ _allWeaveOnLine.Length);
        }


        private void UpdateServerReceiveTb(TextBlock tb, string text)
        {
            tb.Text += text;
        }

        private void SetServerReceiveText(string newtext)
        {
            Action<TextBlock, String> updateAction = new Action<TextBlock, string>(UpdateServerReceiveTb);
            ServerReceive_textBlock.Dispatcher.BeginInvoke(updateAction, ServerReceive_textBlock, newtext);

        }

        public MyListBoxItem CopyUnityPlayerOnClientToMyListBoxItem(UnityPlayerOnClient one)
        {
            MyListBoxItem item = new MyListBoxItem()
            {
                UIName_Id = one.Socket.RemoteEndPoint.ToString(),
                ShowMsg = "UserIP:" + one.Socket.RemoteEndPoint.ToString() + " -Token:" + one.Token,
                UserName = one.UserName,
                Ip = one.Socket.RemoteEndPoint.ToString()
            };
            return item;
        }


        public MyListBoxItem CopyWeaveOnLineToMyListBoxItem(WeaveOnLine  one)
        {
            MyListBoxItem item = new MyListBoxItem()
            {
                UIName_Id = one.Socket.RemoteEndPoint.ToString(),
                ShowMsg = "UserIP:" + one.Socket.RemoteEndPoint.ToString() + " -Token:" + one.Token,
                UserName = "Uname:"+ one.Socket.RemoteEndPoint.ToString(),
                Ip = one.Socket.RemoteEndPoint.ToString()
            };
            return item;
        }


        public void AddListBoxItem(List<MyListBoxItem> sList  , MyListBoxItem one)
        {


            sList.Add(one);
            CheckListBoxSource();
        }

        public void AddListBoxItemAction(List<MyListBoxItem> sList, MyListBoxItem one)
        {
            Action< List < MyListBoxItem >  , MyListBoxItem>  addListBoxItemAction =

                new Action<List<MyListBoxItem>  , MyListBoxItem>(AddListBoxItem);

            this.Dispatcher.BeginInvoke(addListBoxItemAction,sList , one);
        }


        public void RemoveListBoxItem(List<MyListBoxItem> sList, MyListBoxItem one)
        {
            MyListBoxItem item = sList.Find(i=>i.Ip == one.Ip);

            if(item != null)
            {
                sList.Remove(item);
            }


            CheckListBoxSource();
        }

        public void RemoveListBoxItemAction(List<MyListBoxItem> sList, MyListBoxItem one)
        {
            Action<List<MyListBoxItem>, MyListBoxItem> removeListBoxItemAction =

                new Action<List<MyListBoxItem>, MyListBoxItem>(RemoveListBoxItem);

            this.Dispatcher.BeginInvoke(removeListBoxItemAction, sList , one);
        }

        public void CheckListBoxSource()
        {
            //数据发生变化后，重新设置登陆后的用户列表Listbox的数据源
            LoginedUser_listBox.ItemsSource = null;
            LoginedUser_listBox.ItemsSource = loginedUserList;
            //数据发生变化后，重新设置连接到服务器的Socket列表的Listbox的数据源
            ConnectedSocket_listBox.ItemsSource = null;
           ConnectedSocket_listBox.ItemsSource = connectedSocketItemList;
        }

        protected override void OnClosed(EventArgs e)
        {
            weaveTCPcloud.P2Server = null;

            weaveTCPcloud = null;

            //Application.Current.ShutdownMode = ShutdownMode.OnMainWindowClose;
            //if (this.IsAfreshLogin == true) return;
            Application.Current.Shutdown();
            Environment.Exit(0);// 可以立即中断程序执行并退出
            base.OnClosed(e);
        }


    }

    public class MyListBoxItem
    {
        public string UIName_Id { get; set; }

        public string Ip { get; set; }
        public string ShowMsg { get; set; }

        public string UserName { get; set; }
    }
}

XMAL代码

<Window x:Class="WeavingSocketServerWPF.MyUnityServer"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WeavingSocketServerWPF"
        mc:Ignorable="d"
        Title="MyUnityServer"   Height="631.609" Width="998.81">
    <Grid>
        <Label x:Name="label" Content="端口号" HorizontalAlignment="Left" Margin="23,10,0,0" VerticalAlignment="Top" Height="38" Width="111" FontSize="16"/>
        <TextBox x:Name="Port_textBox" HorizontalAlignment="Left" Height="46" Margin="23,53,0,0" TextWrapping="Wrap" Text="10155" VerticalAlignment="Top" Width="130" FontSize="16"/>
        <Button x:Name="StartListen_button" Content="开始监听端口" HorizontalAlignment="Left" Margin="179,53,0,0" VerticalAlignment="Top" Width="115" Height="41" FontSize="18" Click="StartListen_button_Click"/>
        <ListBox x:Name="ConnectedSocket_listBox" HorizontalAlignment="Left" Height="309" Margin="467,53,0,0" VerticalAlignment="Top" Width="519">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <CheckBox  Content="{Binding Path=ShowMsg}"/>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>


        <Label x:Name="UserList_label" Content="连接到服务的Socket列表" HorizontalAlignment="Left" Margin="467,10,0,0" VerticalAlignment="Top" Height="38" Width="194" FontSize="16"/>

        <Label x:Name="label_Copy" Content="收到的信息" HorizontalAlignment="Left" Margin="23,348,0,0" VerticalAlignment="Top" Height="32" Width="111" FontSize="16"/>
        <Label x:Name="label_Copy1" Content="要发送的消息" HorizontalAlignment="Left" Margin="23,131,0,0" VerticalAlignment="Top" Height="38" Width="111" FontSize="16"/>
        <TextBox x:Name="InputSendMessage_textBox" HorizontalAlignment="Left" Height="46" Margin="23,174,0,0" TextWrapping="Wrap" Text="Message" VerticalAlignment="Top" Width="217" FontSize="16"/>
        <Button x:Name="SendMsg_button" Content="发送消息" HorizontalAlignment="Left" Margin="23,247,0,0" VerticalAlignment="Top" Width="217" Height="82" FontSize="18" Click="SendMsg_button_Click"/>
        <Button x:Name="StopListen_button" Content="关闭服务器" HorizontalAlignment="Left" Margin="322,53,0,0" VerticalAlignment="Top" Width="124" Height="41" FontSize="18" Click="StopListen_button_Click"/>
        <ListBox x:Name="LoginedUser_listBox" HorizontalAlignment="Left" Height="212" Margin="300,150,0,0" VerticalAlignment="Top" Width="146">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <CheckBox  Content="{Binding Path=UserName}"/>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
        <Label x:Name="UserList_label_Copy" Content="已登陆玩家" HorizontalAlignment="Left" Margin="300,107,0,0" VerticalAlignment="Top" Height="38" Width="146" FontSize="16" BorderBrush="#FFFB0808" OpacityMask="Red" Foreground="Red"/>
        <ScrollViewer HorizontalAlignment="Left" Height="190" Margin="23,380,0,0" VerticalAlignment="Top" Width="958">
            <ScrollViewer.Content>
                <TextBlock x:Name="ServerReceive_textBlock" HorizontalAlignment="Left" Margin="0,0,0,0" TextWrapping="Wrap" Text="MSG" VerticalAlignment="Top"  Width="963" Foreground="#FFFF1207" Background="#FFD3CDCD" FontSize="14"/>
            </ScrollViewer.Content>
        </ScrollViewer>

    </Grid>
</Window>

界面图

这里写图片描述

WeaveSocket官方QQ群17375149

项目地址：https://gitee.com/dreamsfly900/universal-Data-Communication-System-for-windows/tree/master/Example

本节到此结束，未完待续

superlinmeng
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
unity c#实现简单前后端socket通信框架
11-09
博客：https://blog.csdn.net/u014261855/article/details/109583060 unity c#实现简单前后端socket通信框架 .net dll工程，封装三个工具： 1.服务器 2.客户端 3.通用byte流客户端
Unity通信之Socket架构的业务层使用方法
麦当劳比肯德基好吃
01-28 4130
效果：两个客户端，一个称为客户端A，一个称为客户端B。 一个服务器。 一组协议。 客户端A发送，服务器接受到，并且转发给所有客户端。 客户端A和客户端B接收到服务器的消息转发，并且读取出来，显示到客户端A和客户端B。 1.网络层定义好DTO以及协议。 2. 客户端的chatcontroller可以去拿服务端的DTO以及调api发送DTO给服务端。 3.服务端的controller要接受DTO并且转发。 4.在客户端和服务端的c...
Unity笔记——C#的Socket基础
掩扉Blog
04-13 2165
总的来说TCP通信大致就是六步，建立socket->绑定Bind->监听Listen->通过Accept()与客户端建立连接->客户端Connect()连接服务器->Send()给服务器发送消息->通过Receive()方法来建立连接，从而实现可靠传输。4）通过ReciveFrom()方法接收指定主机发送的消息（需要提供主机IP地址及端口）3）通过SendTo()方法向建立连接的主机发送消息（需要提供IP地址及端口）7）利用Receive()方法接受来自建立连接主机的消息（实现可靠连接）
Unity/C# Socket框架学习遇到的相关方法
weixin_45348216的博客
11-29 1444
unity的socket框架
Unity3D 网络游戏框架(二、同步Socket)
qq_39596597的博客
10-26 1511
0基础Unity网络编程
unity4.3.4f1-----unity3d RPG游戏《外星人》完整源码下载.zip
05-20
unity4.3.4f1-----unity3d RPG游戏《外星人》完整源码下载.zip unity4.3.4f1-----unity3d RPG游戏《外星人》完整源码下载.zip
Spine-unity 3.8
10-09
适用版本 Spine 3.8.x Unity 2017.1-2019.4. 其它版本官方下载地址： http://zh.esotericsoftware.com/spine-unity-download/
unity 3D期末作业-太空飞机射击游戏
07-16
unity 3D期末作业-太空飞机射击游戏（免积分下载），飞机可上下左右移动并发射子弹，有背景音乐，子弹有打击音效，有爆炸声，可以记录分数，飞机碰到障碍物时会爆炸游戏结束，游戏详情请看我发的文章介绍。
Unity游戏源码分享-全民飞机大战源码unity2019
08-11
Unity游戏源码分享-全民飞机大战源码unity2019
Unity游戏项目源码太空银河飞机大战Space Squadron - Galaxy Shooter
最新发布
01-19
Unity游戏项目源码太空银河飞机大战Space Squadron - Galaxy Shooter 支持Unity5.6及以上 你是太空射击游戏的粉丝吗？看看《太空中队: 银河射手》吧，终极的天空之力游戏。你们的任务是在银河系中令人震惊的地方进行...
大厅：Unity中使用SocketWeaver SDK的多人大厅示例项目
02-04
基本大堂 要求 Unity 2018.3.4或更高版本。 您可以在此处下载最新版本的Unity： ： SocketWeaver帐户。 您可以在这里免费创建SocketWeaver帐户： ：//portal.socketweaver.com 所有帐户每月均可免费获得20GB数据。 我们在做什么 在本教程中，我们将建立一个具有以下功能的基本游说区。 自定义玩家名称 自定义房间数据 玩家聊天 聊天室 团队管理 带分页的房间列表 我们将逐步向您展示该过程。 在阅读完本教程时，您将准备开始创建自己的大厅界面和配对逻辑。 源代码 本教程的源代码托管在： : 该存储库有两个Unity项目： 游
Unity C# socket客户端框架
03-22
应用于unity的C# Socket客户端框架，包含完整的通用逻辑与常见的异常处理，可供新人学习使用。该代码并不能够直接运行，仅供阅读和参考。
使用 weaving-socket教学-入门socket与websocket
chunzhen5985的博客
05-05 412
首先把项目下载下来:http://git.oschina.net/dreamsfly900/universal-Data-Communication-System-for-windows 还有一个同胞项目 .NET Core的weaving-socket项目 http://git.os...
Unity【Multiplayer 多人在线】- Socket 通用服务端框架（一）、定义套接字和多路复用
当代野生程序猿
04-08 2922
Socket套接字的定义： 首先编写服务器初始化的方法Init，接受一个参数port，即监听的端口，在Main函数中调用Init传入端口以启动服务器。 using System.Net; using System.Net.Sockets; namespace SK.Framework.Sockets { /// <summary> /// 服务器 /// </summary> public class Server {
Unity3D 网络游戏框架(五、异步服务端Socket)
qq_39596597的博客
10-29 533
这节课我们来开发异步服务端
使用 weaving-socket教学-提升，像调用方法一样通信传输
chunzhen5985的博客
05-06 273
大多数的通信架构只保证里基本数据的传输，在大家编写的过程中还要自己自己编码或解码等内容。然后把数据用一大推的判断来分割起来，保证运行到想要的代码段。那么使用weaving-socket架构的朋友们，你们有福了，现在你只需要定义好方法名称增加一个修饰就可以直接像调用方法类似的手段运行到你只定的方...
Unity3D 网络游戏框架(三、服务端同步Socket)
qq_39596597的博客
10-26 971
Unity服务端开发
一套完整的unity的socket网络通信模块
热门推荐
zgjllf1011的博客
01-31 3万+
这里只讲一些主要内容，完整代码请到我的github里下载：https://github.com/LiuFeng1011/UnityNetWork/tree/master/Assets/Code/Net SocketHelper类 主要的通信类，socket的管理放在这里 下面说一下一些主要的方法 1.连接服务器，这个都写了比较详细的注释，一看就会明白 ///
socketio-for-unity下载
08-10
socketio-for-unity是一个用于Unity引擎的插件，用于在Unity应用程序中实现socket.io协议的通信功能。它提供了一种简单而强大的方式来在Unity应用程序中与服务器进行实时数据交换。 要下载socketio-for-unity，首先...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值