fixed: 继续改battleServer的逻辑.

CSserver/BattleRoom/Program.cs

@@ -3,35 +3,48 @@ using System.Net;
 using System.Net.Sockets;
 using System.Threading.Tasks;
 using System.Diagnostics;
+using System.Collections.Generic;
 using MultiDup;
 namespace BattleRoom
 {
     internal class Program
     {
-        static Socket SocketWatch = null;                                       // 创建一个和客户端通信的套接字 
-        const int port = 6006;                                                  // 端口号（用来监听的） 
-
 
+        const int port = 6006;                                                        // 端口号（用来监听客户端连接的）  
 
         static void Main(string[] args)
-        { 
+        {
             selfTest();
-            IPAddress ip = IPAddress.Any;
-            IPEndPoint ipe = new IPEndPoint(ip, port);                         //将IP地址和端口号绑定到网络节点point上  
-
-            //定义一个套接字用于监听客户端发来的消息，包含三个参数（IP4寻址协议，流式连接，Tcp协议）  
-            SocketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
-            SocketWatch.Bind(ipe);                                             // 监听绑定的网络节点           
-            SocketWatch.Listen(20);                                            // 将套接字的监听队列长度限制为20    
-
             Console.WriteLine("开启监听......");
             Console.WriteLine("ctrl + c 退出程序......");
 
-            Task.Run(WatchConnecting).Wait();                                  // 开启监听线程
-            SocketWatch.Close();                                               // 结束监听socket
+            InitServerPeer();
+
+            Task.Run(WatchConnecting);                                                // 开启监听线程 
 
         }
 
+        /// <summary>
+        /// 初始化服务器间socket
+        /// </summary>
+        async static void InitServerPeer()
+        {
+            var port = 6005;                                                           // 连接本机的大厅服务端口            
+            var endPoint = new IPEndPoint(IPAddress.Loopback, port);   
+ 
+            using (var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
+            {
+                try
+                {
+                    await client.ConnectAsync(endPoint);
+                }
+                catch (Exception ee)
+                {
+                    Debug.WriteLine(ee.Message);
+                }
+                RoomManager.Instance.ServerPeer = new ServerPeer(client);                    // 给管理器的服务器间socket赋值
+            }
+        }
 
         static void selfTest()
         {
@@ -44,7 +57,15 @@ namespace BattleRoom
         /// </summary>
         async static Task WatchConnecting()
         {
-            while (true)                                                                 // 持续不断监听客户端发来的请求     
+            IPAddress ip = IPAddress.Any;
+            IPEndPoint ipe = new IPEndPoint(ip, port);                                 //将IP地址和端口号绑定到网络节点point上  
+
+            //定义一个套接字用于监听客户端发来的消息，包含三个参数（IP4寻址协议，流式连接，Tcp协议）  
+            Socket SocketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+            SocketWatch.Bind(ipe);                                                     // 监听绑定的网络节点           
+            SocketWatch.Listen(20);                                                    // 将套接字的监听队列长度限制为20    
+
+            while (true)                                                               // 持续不断监听客户端发来的请求     
             {
                 Socket connection;
                 try
@@ -57,10 +78,12 @@ namespace BattleRoom
                     break;
                 }
 
-                Lobby.Instance.OnNewPeerConnected(new Peer(connection));                 // 有新客户端连入
+                RoomManager.Instance.OnNewPeerConnected(new Peer(connection));                 // 有新客户端连入
             }
+            SocketWatch.Close();                                                         // 结束监听socket
         }
 
+
     }
 }
 

CSserver/BattleRoom/server/Peer.cs

@@ -7,6 +7,8 @@ using System.Threading.Channels;
 using System.Threading.Tasks;
 using ProtoDataBuff;
 using pb = global::Google.Protobuf;
+
+using MultiDup;
 namespace BattleRoom
 {
     /// <summary>
@@ -180,8 +182,8 @@ namespace BattleRoom
                         switch (CurrentState)
                         {
                             case ClientState.Connected:
-                            case ClientState.InLobby:
-                                await Lobby.Instance.MsgChannel.Writer.WriteAsync(new KeyValuePair<int, sSocketData>(this.Id, _socketData)); // 放入大厅处理队列
+                            case ClientState.InLobby:                                                                                                                 
+                                await RoomManager.Instance.MsgChannel.Writer.WriteAsync(new KeyValuePair<int, sSocketData>(this.Id, _socketData)); // 放入大厅处理队列
                                 break;
                             case ClientState.InRoom:
                             case ClientState.InGame:

CSserver/BattleRoom/server/Room.cs

@@ -8,7 +8,7 @@ using System.Threading.Channels;
 using System.Threading.Tasks;
 using static System.Console;
 using pb = global::Google.Protobuf;
-
+using MultiDup;
 namespace BattleRoom
 {
     /// <summary>

CSserver/BattleRoom/server/Lobby.cs → CSserver/BattleRoom/server/RoomManager.cs

@@ -8,21 +8,26 @@ using System.Threading.Channels;
 using ProtoDataBuff;
 
 using CSharpUtil;
+using MultiDup;
 
 namespace BattleRoom
 {
 
-
     /// <summary>
-    /// 大厅 首先玩家连上来之后进入大厅, 下发当前房间列表, 可以创建/加入房间, 进入房间后归房间管
+    /// 房间管理者, 负责 将连接上来的客户端转移到房间中
     /// </summary>
-    internal class Lobby : Singleton<Lobby>
+    internal class RoomManager : Singleton<RoomManager>
     {
+        /// <summary>
+        /// 服务器间的连接
+        /// </summary>
+        public ServerPeer ServerPeer;
 
         /// <summary>
         /// 客户端
         /// </summary>
         public Dictionary<int, Peer> ClientPeers = new Dictionary<int, Peer>();
+
         /// <summary>
         /// 消息分发
         /// </summary>
@@ -34,10 +39,13 @@ namespace BattleRoom
         public Channel<KeyValuePair<int, sSocketData>> MsgChannel = Channel.CreateBounded<KeyValuePair<int, sSocketData>>(1000);
 
 
+        /// <summary>
+        /// 房间列表
+        /// </summary>
         Dictionary<int, Room> roomDic = new Dictionary<int, Room>();
 
 
-        public Lobby()
+        public RoomManager()
         {
             this.callbacks.Add(eProtocalCommand.CsMdEnterLobby, On_EnterLobby);
             this.callbacks.Add(eProtocalCommand.CsLeaveRoom, On_Leave);
@@ -112,6 +120,7 @@ namespace BattleRoom
                 peer.SendEvent(eProtocalCommand.ScMdGetRoomList, msg);
             }
         }
+
         /// <summary>
         /// 创建一个房间(副本)
         /// </summary>
@@ -123,7 +132,7 @@ namespace BattleRoom
             {
                 peer.SendEvent(eProtocalCommand.ScMdCreateRoom, new SC_MD_CreateRoom() { });
                 var room = new Room(msg.Mapid);
-                room.AddPeer(peer);                   // 转移进房间
+                room.AddPeer(peer);                                                    // 转移进房间
                 roomDic.Add(room.Id, room);
 
                 //RemovePeer(peerId);                                                  // 从大厅移除

CSserver/BattleRoom/server/ServerPeer.cs

@@ -0,0 +1,185 @@
+using StackExchange.Redis;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Sockets;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ProtoDataBuff;
+using pb = global::Google.Protobuf;
+
+using MultiDup;
+namespace BattleRoom
+{
+    internal class ServerPeer
+    {
+
+        /// <summary>
+        /// socket连接
+        /// </summary>
+        public readonly Socket Sock;
+
+        /// <summary>
+        /// 消息分发
+        /// </summary>
+        private Dictionary<eProtocalCommand, Action<sSocketData>> callbacks = new Dictionary<eProtocalCommand, Action<sSocketData>>();
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        /// <param name="sock"></param>
+        public ServerPeer(Socket sock)
+        {
+            this.Sock = sock;
+            Sock.ReceiveTimeout = 1500;                                         // 接收等待超时时间设为1.5秒 
+
+            callbacks.Add(eProtocalCommand.SsCreateBattleRoom, On_CreateBattleRoom);
+
+            var t = Task.Run(() => recv(Sock));                                 // 新建接收线程 
+            var tcs = Task.Run(WriteToClient);                                  // 向客户端发送消息线程
+            var tmsglp = Task.Run(MsgLoop);
+        }
+
+        #region 逻辑处理
+
+        public void On_CreateBattleRoom(sSocketData _sData) {
+
+            var msg = SS_CreateBattleServer.Parser.ParseFrom(_sData._data);
+            // 开辟一个处理对象, room, 然后后续逻辑由room对象等待连接过来. 
+
+
+            // 返回成功
+            this.SendEvent(eProtocalCommand.SsCreateBattleRoomOk, new SS_CreateBattleServerOK() { });
+
+        }
+
+
+        #endregion
+
+
+        public void Close()
+        {
+
+            this.sendDataBuffer.Reader.Completion
+                .ContinueWith(t =>
+                Task.Delay(5000).ContinueWith(t1 => Sock.Close())
+                );                                                               // 延迟5秒关闭套接字
+        }
+
+        #region 消息收发
+
+        async void MsgLoop()
+        {
+            while (true)
+            {
+                var msg = await MsgChannel.Reader.ReadAsync();
+                if (callbacks.ContainsKey(msg._protocallType))
+                {
+                    callbacks[msg._protocallType](msg);
+                }
+                else
+                {
+                    // 未找到消息处理逻辑
+                }
+            }
+        }
+        /// <summary>
+        /// 客户端消息队列
+        /// </summary>
+        public Channel<sSocketData> MsgChannel = Channel.CreateBounded<sSocketData>(1000);
+
+        /// <summary>
+        /// 向客户端发送事件
+        /// </summary>
+        public void SendEvent(eProtocalCommand msgType, pb::IMessage msg)
+        {
+            SendToClient(msgType, msg);
+        }
+
+        /// <summary>
+        /// 向客户端发送消息
+        /// </summary>
+        /// <param name="msgType"></param>
+        /// <param name="msg"></param>
+        void SendToClient(eProtocalCommand msgType, pb::IMessage msg)
+        {
+            using var ms = new MemoryStream();
+            using var os = new pb::CodedOutputStream(ms);
+            msg.WriteTo(os);
+            os.Flush();
+            ms.Seek(0, SeekOrigin.Begin);
+            var sdata = sSocketData.FromBytes(msgType, ms.ToArray());
+            sendDataBuffer.Writer.WriteAsync(sdata).AsTask().Wait();
+        }
+
+
+        /// <summary>
+        /// 向客户端写入消息
+        /// </summary>
+        async void WriteToClient()
+        {
+            while (true)
+            {
+                try
+                {
+                    var msg = await sendDataBuffer.Reader.ReadAsync();
+                    await Sock.SendAsync(new ArraySegment<byte>(msg.ToBytes()), SocketFlags.None);
+                }
+                catch (Exception)
+                {
+                    break;
+                }
+
+            }
+            Close();
+        }
+
+
+        /// <summary>
+        /// 发送buffer
+        /// </summary>
+        private Channel<sSocketData> sendDataBuffer = Channel.CreateUnbounded<sSocketData>();
+
+        /// <summary>
+        /// 接收客户端发来的信息，客户端套接字对象
+        /// </summary>
+        /// <param name="socketclientpara"></param>    
+        async void recv(Socket socketServer)
+        {
+            var _databuffer = new DataBuffer();
+            byte[] arrServerRecMsg = new byte[4096];                                       // 创建一个内存缓冲区，其大小为4k字节  
+            while (true)
+            {
+                try
+                {
+                    var length = await socketServer.ReceiveAsync(new ArraySegment<byte>(arrServerRecMsg), SocketFlags.None);   // 将接收到的信息存入到内存缓冲区，并返回其字节数组的长度    
+                    if (length <= 0)                                                       // 视为客户端已经close连接
+                    {
+                        break;
+                    }
+                    _databuffer.AddBuffer(arrServerRecMsg, length);                         //将收到的数据添加到缓存器中
+                    while (_databuffer.GetData(out sSocketData _socketData))                //取出一条完整数据,转到room的消息队列,由room统一进行逻辑处理 
+                    {
+                        Console.WriteLine(" recv: " + _socketData._protocallType);
+                        await MsgChannel.Writer.WriteAsync(_socketData);                    // 放入大厅处理队列
+                    }
+                    Array.Clear(arrServerRecMsg, 0, length);
+                }
+                catch (SocketException e)
+                {
+                    if (e.ErrorCode == 10060)                                                  // 超时的时候错误号码是10060
+                    {
+                        continue;                                                              // 继续等待  
+                    }
+                    break;
+                }
+                catch (Exception)
+                {
+                    break;
+                }
+            }
+
+            Close();                                                                 // 关闭
+        }
+        #endregion
+    }
+}

CSserver/MultiDup/Program.cs

@@ -9,24 +9,22 @@ namespace MultiDup
 {
     internal class Program
     {
-        static Socket SocketWatch = null;                                       // 创建一个和客户端通信的套接字 
+        const int serverport = 6005;                                            // 用于监听服务端连接的端口号
+
+        static ServerPeer serverPeer = null;                                             // 战斗server的连接
+
         const int port = 6004;                                                  // 端口号（用来监听的） 
         static void Main(string[] args)
         {
             selfTest();
-            IPAddress ip = IPAddress.Any;
-            IPEndPoint ipe = new IPEndPoint(ip, port);                         //将IP地址和端口号绑定到网络节点point上  
-
-            //定义一个套接字用于监听客户端发来的消息，包含三个参数（IP4寻址协议，流式连接，Tcp协议）  
-            SocketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
-            SocketWatch.Bind(ipe);                                             // 监听绑定的网络节点           
-            SocketWatch.Listen(20);                                            // 将套接字的监听队列长度限制为20    
 
             Console.WriteLine("开启监听......");
             Console.WriteLine("ctrl + c 退出程序......");
 
-            Task.Run(WatchConnecting).Wait();                                  // 开启监听线程
-            SocketWatch.Close();                                               // 结束监听socket
+            Task[] tasks = new Task[2];
+            tasks[0] = Task.Run(WatchConnecting);
+            tasks[1] = Task.Run(WatchServerPeerConnecting);
+            Task.WaitAll(tasks);                                                // 开启监听线程 
 
         }
 
@@ -42,6 +40,14 @@ namespace MultiDup
         /// </summary>
         async static Task WatchConnecting()
         {
+            IPAddress ip = IPAddress.Any;
+            IPEndPoint ipe = new IPEndPoint(ip, port);                         //将IP地址和端口号绑定到网络节点point上  
+
+            //定义一个套接字用于监听客户端发来的消息，包含三个参数（IP4寻址协议，流式连接，Tcp协议）  
+            Socket SocketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+            SocketWatch.Bind(ipe);                                             // 监听绑定的网络节点           
+            SocketWatch.Listen(20);                                            // 将套接字的监听队列长度限制为20    
+
             while (true)                                                                 // 持续不断监听客户端发来的请求     
             {
                 Socket connection;
@@ -57,7 +63,37 @@ namespace MultiDup
 
                 Lobby.Instance.OnNewPeerConnected(new Peer(connection));                 // 有新客户端连入
             }
+            SocketWatch.Close();                                               // 结束监听socket
         }
+        /// <summary>
+        /// 监听服务端发来的请求  
+        /// </summary>
+        async static Task WatchServerPeerConnecting()
+        {
+            IPAddress ip = IPAddress.Any;
+            IPEndPoint ipe = new IPEndPoint(ip, serverport);                             //将IP地址和端口号绑定到网络节点point上  
 
+            //定义一个套接字用于监听客户端发来的消息，包含三个参数（IP4寻址协议，流式连接，Tcp协议）  
+            Socket SocketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+            SocketWatch.Bind(ipe);                                                       // 监听绑定的网络节点           
+            SocketWatch.Listen(20);                                                      // 将套接字的监听队列长度限制为20    
+
+            while (true)                                                                 // 持续不断监听客户端发来的请求     
+            {
+                Socket connection;
+                try
+                {
+                    connection = await SocketWatch.AcceptAsync();
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine(ex.Message);                                       // 提示套接字监听异常     
+                    break;
+                }
+
+                serverPeer = new ServerPeer(connection);                                 // 建立与服务端的连接
+            }
+            SocketWatch.Close();                                                         // 结束监听socket
+        }
     }
 }

CSserver/MultiDup/server/ServerPeer.cs

@@ -0,0 +1,184 @@
+using StackExchange.Redis;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Sockets;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using ProtoDataBuff;
+using pb = global::Google.Protobuf;
+
+namespace MultiDup
+{
+    internal class ServerPeer
+    {
+
+        /// <summary>
+        /// socket连接
+        /// </summary>
+        public readonly Socket Sock;
+
+        /// <summary>
+        /// 消息分发
+        /// </summary>
+        private Dictionary<eProtocalCommand, Action<sSocketData>> callbacks = new Dictionary<eProtocalCommand, Action<sSocketData>>();
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        /// <param name="sock"></param>
+        public ServerPeer(Socket sock)
+        {
+            this.Sock = sock;
+            Sock.ReceiveTimeout = 1500;                                         // 接收等待超时时间设为1.5秒 
+
+            callbacks.Add(eProtocalCommand.SsCreateBattleRoom, On_CreateBattleRoom);
+
+            var t = Task.Run(() => recv(Sock));                                 // 新建接收线程 
+            var tcs = Task.Run(WriteToClient);                                  // 向客户端发送消息线程
+            var tmsglp = Task.Run(MsgLoop);
+        }
+
+        #region 逻辑处理
+
+        public void On_CreateBattleRoom(sSocketData _sData)
+        {
+
+            var msg = SS_CreateBattleServer.Parser.ParseFrom(_sData._data);
+            // 开辟一个处理对象, room, 然后后续逻辑由room对象等待连接过来. 
+
+
+            // 返回成功
+            this.SendEvent(eProtocalCommand.SsCreateBattleRoomOk, new SS_CreateBattleServerOK() { });
+
+        }
+
+
+        #endregion
+
+        public void Close()
+        {
+
+            this.sendDataBuffer.Reader.Completion
+                .ContinueWith(t =>
+                Task.Delay(5000).ContinueWith(t1 => Sock.Close())
+                );                                                               // 延迟5秒关闭套接字
+        }
+
+        #region 消息收发
+
+        async void MsgLoop()
+        {
+            while (true)
+            {
+                var msg = await MsgChannel.Reader.ReadAsync();
+                if (callbacks.ContainsKey(msg._protocallType))
+                {
+                    callbacks[msg._protocallType](msg);
+                }
+                else
+                {
+                    // 未找到消息处理逻辑
+                }
+            }
+        }
+        /// <summary>
+        /// 客户端消息队列
+        /// </summary>
+        public Channel<sSocketData> MsgChannel = Channel.CreateBounded<sSocketData>(1000);
+
+        /// <summary>
+        /// 向客户端发送事件
+        /// </summary>
+        public void SendEvent(eProtocalCommand msgType, pb::IMessage msg)
+        {
+            SendToClient(msgType, msg);
+        }
+
+        /// <summary>
+        /// 向客户端发送消息
+        /// </summary>
+        /// <param name="msgType"></param>
+        /// <param name="msg"></param>
+        void SendToClient(eProtocalCommand msgType, pb::IMessage msg)
+        {
+            using var ms = new MemoryStream();
+            using var os = new pb::CodedOutputStream(ms);
+            msg.WriteTo(os);
+            os.Flush();
+            ms.Seek(0, SeekOrigin.Begin);
+            var sdata = sSocketData.FromBytes(msgType, ms.ToArray());
+            sendDataBuffer.Writer.WriteAsync(sdata).AsTask().Wait();
+        }
+
+
+        /// <summary>
+        /// 向客户端写入消息
+        /// </summary>
+        async void WriteToClient()
+        {
+            while (true)
+            {
+                try
+                {
+                    var msg = await sendDataBuffer.Reader.ReadAsync();
+                    await Sock.SendAsync(new ArraySegment<byte>(msg.ToBytes()), SocketFlags.None);
+                }
+                catch (Exception)
+                {
+                    break;
+                }
+
+            }
+            Close();
+        }
+
+
+        /// <summary>
+        /// 发送buffer
+        /// </summary>
+        private Channel<sSocketData> sendDataBuffer = Channel.CreateUnbounded<sSocketData>();
+
+        /// <summary>
+        /// 接收客户端发来的信息，客户端套接字对象
+        /// </summary>
+        /// <param name="socketclientpara"></param>    
+        async void recv(Socket socketServer)
+        {
+            var _databuffer = new DataBuffer();
+            byte[] arrServerRecMsg = new byte[4096];                                       // 创建一个内存缓冲区，其大小为4k字节  
+            while (true)
+            {
+                try
+                {
+                    var length = await socketServer.ReceiveAsync(new ArraySegment<byte>(arrServerRecMsg), SocketFlags.None);   // 将接收到的信息存入到内存缓冲区，并返回其字节数组的长度    
+                    if (length <= 0)                                                       // 视为客户端已经close连接
+                    {
+                        break;
+                    }
+                    _databuffer.AddBuffer(arrServerRecMsg, length);                         //将收到的数据添加到缓存器中
+                    while (_databuffer.GetData(out sSocketData _socketData))                //取出一条完整数据,转到room的消息队列,由room统一进行逻辑处理 
+                    {
+                        Console.WriteLine(" recv: " + _socketData._protocallType);
+                        await MsgChannel.Writer.WriteAsync(_socketData);                    // 放入大厅处理队列
+                    }
+                    Array.Clear(arrServerRecMsg, 0, length);
+                }
+                catch (SocketException e)
+                {
+                    if (e.ErrorCode == 10060)                                                  // 超时的时候错误号码是10060
+                    {
+                        continue;                                                              // 继续等待  
+                    }
+                    break;
+                }
+                catch (Exception)
+                {
+                    break;
+                }
+            }
+
+            Close();                                                                 // 关闭
+        }
+        #endregion
+    }
+}

CSserver/PBReferens/pb/MsgTypeEnum.proto

@@ -40,6 +40,14 @@ enum eProtocalCommand {
   // 多人副本, 开始游戏(创建者)
   CS_MD_BeginDup = 25;
 
+  // 战斗服务 登录
+  CS_BT_Login=31;
+  // 战斗服务 状态同步
+  CS_BT_Status=32;
+  // 战斗服务 位置同步
+  CS_BT_Position=33;
+  // 战斗服务 广播
+  CS_BT_BroadCast =34;
 
   //
   //=======  S => C  =======
@@ -72,6 +80,14 @@ enum eProtocalCommand {
   // 多人副本, 开始游戏(创建者)
   SC_MD_BeginDup = 125;
 
+  // 战斗服务 登录通知
+  SC_BT_Login = 131;
+  // 战斗服务 状态同步
+  SC_BT_Status =132;
+  // 战斗服务 位置同步
+  SC_BT_Postion =133;
+  // 战斗服务 广播
+  SC_BT_BroadCast =134;
 
   //////////////   S - S    //////////////////
   //创建战斗房间

CSserver/PBReferens/pb/MultiDup.proto

@@ -41,6 +41,31 @@ package MultiDup;
 	 //int32 RoomId=3;    // 房间id (理论上已经处于房间中不需要此字段)
  }
 
+ message CS_BT_Login{
+ 	 int32 Zoneid=1;
+	 string Uid =2;
+	 string Msg=3;
+ }
+ message CS_BT_Status{
+	 int32 Zoneid=1;
+	 string SenderUid =2;
+	 string PropertyName=3;
+	 string Value=4;
+ }
+ message CS_BT_Position{
+  	 int32 Zoneid=1;
+	 string SenderUid =2;
+	 float  X =3;
+	 float  Y =4;
+	 float  Z =5;
+ }
+
+ message CS_BT_BroadCast{
+  	 int32 Zoneid=1;
+	 string SenderUid =2;
+	 string Msg=3;
+ }
+
 
  // 
  // 加入房间成功
@@ -88,6 +113,41 @@ package MultiDup;
       
  }
 
+ // 战斗服务 登录
+ 
+ message SC_BT_Login{
+ 	 int32 Zoneid=1;
+	 string Uid =2;
+	 string Msg=3;
+ }
+ // 战斗服务 同步状态
+ message SC_BT_Status{
+	 int32 Zoneid=1;
+	 string SenderUid =2;
+	 // 属性名称
+	 string PropertyName=3;
+	 // 属性值
+	 string Value=4;
+ }
+ // 战斗服务 同步位置
+ message SC_BT_Position{
+  	 int32 Zoneid=1;
+	   // 发送者uid
+	 string SenderUid =2;
+	 float  X =3;
+	 float  Y =4;
+	 float  Z =5;
+ }
+ // 战斗服务 
+ message SC_BT_BroadCast{
+  	 int32 Zoneid=1;
+	   // 发送者uid
+	 string SenderUid =2;
+	 string Msg=3;
+ }
+
+
+
  // 多人副本在战斗服创建房间
  message SS_CreateBattleServer{
 	int32 RoomId=1;

CSserver/PBReferens/pbcs/MsgTypeEnum.cs

@@ -20,19 +20,23 @@ public static partial class MsgTypeEnumReflection {
   static MsgTypeEnumReflection() {
     byte[] descriptorData = global::System.Convert.FromBase64String(
         string.Concat(
-          "ChRwYi9Nc2dUeXBlRW51bS5wcm90byqhBAoQZVByb3RvY2FsQ29tbWFuZBII",
+          "ChRwYi9Nc2dUeXBlRW51bS5wcm90byq8BQoQZVByb3RvY2FsQ29tbWFuZBII",
           "CgRub29wEAASDAoIQ1NfTG9naW4QARITCg9DU19SZXBvcnREYW1hZ2UQAhIQ",
           "CgxDU19MZWF2ZVJvb20QAxITCg9DU19SZXBvcnRVc2VySHAQBBIQCgxDU19D",
           "aGF0TG9naW4QChISCg5DU19DaGF0U2VuZE1zZxALEhQKEENTX01EX0VudGVy",
           "TG9iYnkQFBIUChBDU19NRF9DcmVhdGVSb29tEBUSFQoRQ1NfTURfR2V0Um9v",
           "bUxpc3QQFhITCg9DU19NRF9FbnRlclJvb20QFxITCg9DU19NRF9MZWF2ZVJv",
-          "b20QGBISCg5DU19NRF9CZWdpbkR1cBAZEgwKCFNDX0xvZ2luEGQSFwoTU0Nf",
-          "VXBkYXRlUHJvcGVydGllcxBlEg8KC1NDX0dhbWVPdmVyEGYSEAoMU0NfQ2hh",
-          "dExvZ2luEG4SEQoNU0NfQ2hhdE5ld01zZxBvEhQKEFNDX01EX0VudGVyTG9i",
-          "YnkQeBIUChBTQ19NRF9DcmVhdGVSb29tEHkSFQoRU0NfTURfR2V0Um9vbUxp",
-          "c3QQehITCg9TQ19NRF9FbnRlclJvb20QexITCg9TQ19NRF9MZWF2ZVJvb20Q",
-          "fBISCg5TQ19NRF9CZWdpbkR1cBB9EhgKE1NTX0NyZWF0ZUJhdHRsZVJvb20Q",
-          "rQISGgoVU1NfQ3JlYXRlQmF0dGxlUm9vbU9rEK4CYgZwcm90bzM="));
+          "b20QGBISCg5DU19NRF9CZWdpbkR1cBAZEg8KC0NTX0JUX0xvZ2luEB8SEAoM",
+          "Q1NfQlRfU3RhdHVzECASEgoOQ1NfQlRfUG9zaXRpb24QIRITCg9DU19CVF9C",
+          "cm9hZENhc3QQIhIMCghTQ19Mb2dpbhBkEhcKE1NDX1VwZGF0ZVByb3BlcnRp",
+          "ZXMQZRIPCgtTQ19HYW1lT3ZlchBmEhAKDFNDX0NoYXRMb2dpbhBuEhEKDVND",
+          "X0NoYXROZXdNc2cQbxIUChBTQ19NRF9FbnRlckxvYmJ5EHgSFAoQU0NfTURf",
+          "Q3JlYXRlUm9vbRB5EhUKEVNDX01EX0dldFJvb21MaXN0EHoSEwoPU0NfTURf",
+          "RW50ZXJSb29tEHsSEwoPU0NfTURfTGVhdmVSb29tEHwSEgoOU0NfTURfQmVn",
+          "aW5EdXAQfRIQCgtTQ19CVF9Mb2dpbhCDARIRCgxTQ19CVF9TdGF0dXMQhAES",
+          "EgoNU0NfQlRfUG9zdGlvbhCFARIUCg9TQ19CVF9Ccm9hZENhc3QQhgESGAoT",
+          "U1NfQ3JlYXRlQmF0dGxlUm9vbRCtAhIaChVTU19DcmVhdGVCYXR0bGVSb29t",
+          "T2sQrgJiBnByb3RvMw=="));
     descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
         new pbr::FileDescriptor[] { },
         new pbr::GeneratedClrTypeInfo(new[] {typeof(global::eProtocalCommand), }, null));
@@ -95,6 +99,22 @@ public enum eProtocalCommand {
   /// </summary>
   [pbr::OriginalName("CS_MD_BeginDup")] CsMdBeginDup = 25,
   /// <summary>
+  /// 战斗服务 登录
+  /// </summary>
+  [pbr::OriginalName("CS_BT_Login")] CsBtLogin = 31,
+  /// <summary>
+  /// 战斗服务 状态同步
+  /// </summary>
+  [pbr::OriginalName("CS_BT_Status")] CsBtStatus = 32,
+  /// <summary>
+  /// 战斗服务 位置同步
+  /// </summary>
+  [pbr::OriginalName("CS_BT_Position")] CsBtPosition = 33,
+  /// <summary>
+  /// 战斗服务 广播
+  /// </summary>
+  [pbr::OriginalName("CS_BT_BroadCast")] CsBtBroadCast = 34,
+  /// <summary>
   /// 登录结果
   /// </summary>
   [pbr::OriginalName("SC_Login")] ScLogin = 100,
@@ -140,6 +160,22 @@ public enum eProtocalCommand {
   /// </summary>
   [pbr::OriginalName("SC_MD_BeginDup")] ScMdBeginDup = 125,
   /// <summary>
+  /// 战斗服务 登录通知
+  /// </summary>
+  [pbr::OriginalName("SC_BT_Login")] ScBtLogin = 131,
+  /// <summary>
+  /// 战斗服务 状态同步
+  /// </summary>
+  [pbr::OriginalName("SC_BT_Status")] ScBtStatus = 132,
+  /// <summary>
+  /// 战斗服务 位置同步
+  /// </summary>
+  [pbr::OriginalName("SC_BT_Postion")] ScBtPostion = 133,
+  /// <summary>
+  /// 战斗服务 广播
+  /// </summary>
+  [pbr::OriginalName("SC_BT_BroadCast")] ScBtBroadCast = 134,
+  /// <summary>
   ///////////////   S - S    //////////////////
   ///创建战斗房间
   /// </summary>