/// <summary>
/// 接收消息
/// </summary>
/// <param name="clientSocket"></param>
private static void ReceiveMessage(object _data)
{
DP_Msg data = (DP_Msg)_data;
while (!data.m_bError)
{
Thread.Sleep(10);
//lock (data.m_Lock)
{
Queue <WfPacket> local_RecvQueue = data.m_RecvQueue;
Queue <WfPacket> local_SendQueue = data.m_SendQueue;
object local_Lock = data.m_Lock;
PacketHandlerMgr local_PacketHandlerMgr = data.m_PacketHandlerMgr;
Socket myClientSocket = data.clientSocket;
string text = null;
bool flag = false;
byte[] array = new byte[WfPacket.GetHeaderLength()];
byte[] array2 = null;
int num = 0;
do
{
text = ServerNet.RecvAll(data, ref array, ref array2, ref num, ref flag);
if (num != 0)
{
data.m_LastConnTime = Environment.TickCount;
}
}while (text == null && !flag);
}
}
Log.print("线程{0}ReceiveMessage结束。", data.clientSocket.RemoteEndPoint.ToString());
}
public static void ProcessPacket(WfPacket packet)
{
ushort msgType = 0;
ushort msgLength = 0;
packet.ReadHeader(ref msgType, ref msgLength);
if (NetworkManager.GetEnableDebug(NetworkProtol.Tcp))
{
Debug.Log("收到:" + Convert.ToString(msgType, 16));
}
System.Action <WfPacket> hander = null;
if (!m_Handlers.TryGetValue(msgType, out hander))
{
//Debug.LogWarning("msg not find in battle, will process in hotfix" + Convert.ToString(msgType, 16));
//PacketHandlerMgrHF_ProcessPacket.SafeInvoke((int)msgType, (int)msgLength, packet);
}
else
{
try
{
hander(packet);
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
}
//登录服消息返回
private void SC_LoginRst(WfPacket packet)
{
//获取登录服务器信息
SC_LoginRst pak = PooledClassManagerHF <SC_LoginRst> .CreateClass();
pak.DeSerialize(packet);
int result = pak.m_rst;
if (result == 0)
{
m_Login.m_GameServers.Clear();
GameServerInfo info = new GameServerInfo();
info.m_szIp = m_Login.m_LoginInfo.m_szIp;
info.m_iPort = 24000;
info.m_SessionId = pak.m_sessionid;
m_Login.m_GameServers.Add(info);
Debug.Log("获取服务器信息成功：" + info.m_SessionId);
m_LoginRst = emLoginResult.emLoginResult_OK;
CGameProcedure.SetProcedureStatus((int)LoginStatus.LoginRst_Ok);
//连接游戏服务器
//StartLoginGame();
}
else
{
m_LoginRst = emLoginResult.emLoginResult_Failed;
CGameProcedure.SetProcedureStatus((int)LoginStatus.LoginRst_Ok);
Debug.LogError("登录失败");
}
pak.DestroyClass();
}
private static string SendAll(DP_Msg data, WfPacket msgSending, ref int nSended)
{
SocketError socketError;
int num = data.clientSocket.Send(msgSending.GetBytes(), nSended, msgSending.GetOffset() - nSended, SocketFlags.None, out socketError);
string result;
if (num < 0)
{
result = "SendData < 0";
}
else
{
if (socketError != SocketError.Success && socketError != SocketError.WouldBlock)
{
result = "SendData Failed";
}
else
{
nSended += num;
if (nSended > msgSending.GetOffset())
{
result = "SendData IO error";
}
else
{
result = null;
}
}
}
return(result);
}
private string SendAll(WfPacket msgSending, ref int nSended)
{
SocketError socketError;
int sendNum = m_Socket.Send(msgSending.GetReadBytes(), nSended, msgSending.GetOffset() - nSended, SocketFlags.None, out socketError);
string result;
if (sendNum < 0)
{
result = "SendData < 0";
}
else
{
if (socketError != SocketError.Success && socketError != SocketError.WouldBlock)
{
result = "SendData Failed";
}
else
{
nSended += sendNum;
if (nSended > msgSending.GetOffset())
{
result = "SendData IO error";
}
else
{
result = null;
}
}
}
//Debug.Log("底层函数发送数据给服务器："+socketError.ToString());
return(result);
}
public void ProcessPacket(ClientSession socket, WfPacket packet)
{
ushort msgType = 0;
ushort msgLength = 0;
packet.ReadHeader(ref msgType, ref msgLength);
if (ServerNet.GetEnableDebug())
{
Debug.Log("receive:" + Convert.ToString(msgType, 16));
}
System.Action <ClientSession, WfPacket> packetHandler = (System.Action <ClientSession, WfPacket>)m_KCPPacketHandlers[(ushort)msgType];
if (packetHandler == null)
{
Debug.Log("msg not process=" + msgType.ToString());
}
else
{
try
{
packetHandler(socket, packet);
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
}
public override void DeSerialize(WfPacket r)
{
m_ObjId = r.ReadInt();
m_SkillId = r.ReadUInt();
m_x = r.ReadInt();
m_y = r.ReadInt();
m_TargetId = r.ReadInt();
}
public override void DeSerialize(WfPacket r)
{
m_type = r.ReadInt();
m_account = r.ReadString();
m_pwd = r.ReadString();
m_equipment = r.ReadString();
m_machine = r.ReadString();
}
public override void Serialize(WfPacket w)
{
w.Write(m_type);
w.Write(m_account);
w.Write(m_pwd);
w.Write(m_equipment);
w.Write(m_machine);
}
public override void Serialize(WfPacket w)
{
w.Write(m_ObjId);
w.Write(m_SkillId);
w.Write(m_x);
w.Write(m_y);
w.Write(m_TargetId);
}
private static void OnClientMsg(ClientSession socket, WfPacket pak)
{
int logicCount = pak.ReadInt();
WfPacket msg = new WfPacket(0, 300);
msg.Write((int)logicCount);
KCPNet.SendPacket(socket, msg);
UnityEngine.Debug.Log("Send msg" + logicCount.ToString());
}
private void OnPlayerInfo(WfPacket packet)
{
SC_PlayerInfo pak = new SC_PlayerInfo();
pak.DeSerialize(packet);
LeaveLoginScene();
CGameProcedure.SetActiveProc(CGameProcedure.s_ProcLobby);
}
public static void SendPacket(DP_Msg data, WfPacket msg)
{
lock (data.m_Lock)
{
if (m_bEnableDebug)
{
Log.print("sending:" + msg.m_Command + " to " + data.clientSocket.RemoteEndPoint.ToString());
}
data.m_SendQueue.Enqueue(msg);
}
}
public void Update()
{
if (!IsNetRun())
{
return;
}
if (m_ConnectState == EConnectState.Connected)
{
if (m_uNextCheckTime < (int)UnityEngine.Time.realtimeSinceStartup)
{
m_uNextCheckTime = (uint)UnityEngine.Time.realtimeSinceStartup + 1000u;
//这里只能检测客户端网络环境，无法反应是否已经掉线。
if (m_CurNetwork != Application.internetReachability)
{
Shutdown();
Debug.Log("internetReachability Network changed");
}
}
object privateLockObject;
Monitor.Enter(privateLockObject = m_PrivateLockObject);
try
{
while (m_RecvQueue.Count > 0)
{
WfPacket packet = m_RecvQueue.Dequeue();
GameDll.PacketHandlerManager.ProcessPacket(packet);
packet.DestroyClass();
}
//对消息进行一个分帧优化处理
//int count = m_RecvQueue.Count;
//if (count >= 10)
//{
// for (int i = 0; i < 10; ++i)
// {
// //我们只要先收到的10条消息在这帧处理
// WfPacket packet = m_RecvQueue.Dequeue();
// PacketHandlerMgr.GetInstance().ProcessPacket(packet);
// }
//}
//else
//{
// for (int i = 0; i < count; ++i)
// {
// WfPacket packet = m_RecvQueue.Dequeue();
// PacketHandlerMgr.GetInstance().ProcessPacket(packet);
// }
//}
}
finally
{
Monitor.Exit(privateLockObject);
}
}
}
// 服务器发送给客户端
/// <summary>
/// WfPacket:来自服务器的原始包数据
/// SC_PreBattle：解析包数据的包体
/// DeSerialize：反序列化操作
/// 说明：反序列化结束后，就可以像var playerdatas = pak.datas;使用字段了。
/// </summary>
/// <param name="obj"></param>
private void ResPreBattle(WfPacket obj)
{
Debug.Log("ResPreBattle");
SC_PreBattle pak = new SC_PreBattle();
//演示提示：反序列化到SC_PreBattle类
pak.DeSerialize(obj);
var playerdatas = pak.datas;
m_IsReceived = true;
}
private static void OnClientMsg(DP_Msg socket, WfPacket pak)
{
Packet_StopMove msg = new Packet_StopMove();
msg.DeSerialize(pak);
int objId = msg.m_ObjId;
UnityEngine.Debug.Log("收到客户端消息，ObjId：" + objId);
SendMsg(socket);
}
public override void DeSerialize(WfPacket r)
{
int _TempSize = 0;
_TempSize = r.ReadInt();
for (int i = 0; i < _TempSize; ++i)
{
var _var = new t_PreparePlayerData();
_var.DeSerialize(r);
datas.Add(_var);
}
}
public override void Serialize(WfPacket w)
{
int _TempSize = 0;
_TempSize = datas.Count;
w.Write(_TempSize);
for (int i = 0; i < _TempSize; ++i)
{
var _var = datas[i];
_var.Serialize(w);
}
}
public static void SendPacket(NetworkProtol np, WfPacket pak)
{
pak.Swap();
if (np == NetworkProtol.Tcp)
{
m_TcpNet.SendPacket(pak);
}
else if (np == NetworkProtol.Kcp)
{
//m_KcpNet.SendPacket(pak);
}
}
public void SendPacket(WfPacket msg)
{
object privateLockObject;
Monitor.Enter(privateLockObject = m_PrivateLockObject);
try
{
m_SendQueue.Enqueue(msg);
}
finally
{
Monitor.Exit(privateLockObject);
}
}
public static void ProcessPacket(int msgType, int msgLength, WfPacket packet)
{
//此时包内已经处理了ReadHeader
if (m_Handlers.ContainsKey(msgType))
{
try
{
m_Handlers[msgType](packet);
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
}
public static void SendPacket(NetworkProtol np, ISerializePacket msg, ushort msgType)
{
WfPacket pak = PooledClassManager <WfPacket> .CreateClass();
pak.InitWrite(msgType);
msg.Serialize(pak);
pak.Swap();
if (np == NetworkProtol.Tcp)
{
SendPacket(np, pak);
}
else if (np == NetworkProtol.Kcp)
{
//WfPacket pak = new WfPacket(msgType, 548);
SendPacket(np, pak);
}
}
public static bool ParseHeader(byte[] packetHeader, ref ushort msgType, ref ushort msgLength)
{
bool result;
if (packetHeader.Length < WfPacket.GetHeaderLength())
{
result = false;
}
else
{
msgLength = BitConverter.ToUInt16(packetHeader, 0);
msgType = BitConverter.ToUInt16(packetHeader, 2);
uint server_use = BitConverter.ToUInt32(packetHeader, 4);
result = true;
}
return(result);
}
//自己给自己发消息，用于测试
public static void SendPacketToMe(NetworkProtol np, ISerializePacket msg, ushort msgType)
{
WfPacket pak = PooledClassManager <WfPacket> .CreateClass();
pak.InitWrite(msgType);
msg.Serialize(pak);
pak.Swap();
if (np == NetworkProtol.Tcp)
{
GameDll.PacketHandlerManager.ProcessPacket(pak);
}
else if (np == NetworkProtol.Kcp)
{
//KCPPacketHandlerMgr.GetInstance().ProcessPacket(pak);
}
pak.DestroyClass();
pak = null;
}
private static void SendMessage(object _data)
{
DP_Msg data = (DP_Msg)_data;
while (!data.m_bError)
{
Thread.Sleep(10);
// lock (data.m_Lock)
{
Queue <WfPacket> local_RecvQueue = data.m_RecvQueue;
Queue <WfPacket> local_SendQueue = data.m_SendQueue;
object local_Lock = data.m_Lock;
PacketHandlerMgr local_PacketHandlerMgr = data.m_PacketHandlerMgr;
Socket myClientSocket = data.clientSocket;
WfPacket msgPacket = null;
string text = null;
//处理发送消息
while (local_SendQueue.Count > 0 || msgPacket != null)
{
int num2 = 0;
if (msgPacket != null)
{
text = SendAll(data, msgPacket, ref num2);
if (num2 == msgPacket.GetOffset())
{
msgPacket = null;
}
}
if (text != null || msgPacket != null || local_SendQueue.Count <= 0)
{
break;
}
num2 = 0;
msgPacket = local_SendQueue.Dequeue();
msgPacket.SetHeadLength();
}
}
}
Log.print("线程{0}SendMessage结束。", data.clientSocket.RemoteEndPoint.ToString());
}
static void server_RecvData(ClientSession session, byte[] data, int offset, int size)
{
//byte cmd = data[offset];
//offset++;
//收到马上转发
//string s = System.Text.Encoding.UTF8.GetString(data, offset + 4, size - 4);
//Console.WriteLine("Recv From:" + session.NetIndex.ToString() + " " + session.EndPoint.ToString() + " data:" + s);
//session.Send(s);
UnityEngine.Debug.Log("server_RecvData");
//读4个字节的Key校验
uint key = BitConverter.ToUInt32(data, offset);
int length = data.Length - offset - 4;
byte[] msg = new byte[length];
Array.Copy(data, offset + 4, msg, 0, length);
WfPacket item = new WfPacket(msg);
//向逻辑层抛
KCPPacketHandlerMgr.GetInstance().ProcessPacket(session, item);
}
public override void DeSerialize(WfPacket r)
{
m_ObjId = r.ReadInt();
m_curx = r.ReadInt();
m_curz = r.ReadInt();
int _TempSize = 0;
_TempSize = r.ReadInt();
for (int i = 0; i < _TempSize; ++i)
{
int _var = r.ReadInt();
m_xlist.Add(_var);
}
_TempSize = r.ReadInt();
for (int i = 0; i < _TempSize; ++i)
{
int _var = r.ReadInt();
m_zlist.Add(_var);
}
}
public static void SendMsg(DP_Msg socket)
{
SC_PreBattle sendPak = new SC_PreBattle();
sendPak.datas = new List <t_PreparePlayerData>();
for (uint i = 0; i < 3; ++i)
{
t_PreparePlayerData data = new t_PreparePlayerData();
data.m_jobid = i;
data.m_playerid = i;
data.m_name = "Player" + i;
sendPak.datas.Add(data);
}
WfPacket sendPak2 = new WfPacket((ushort)emPacket_Battle.em_SC_PreBattle);
sendPak.Serialize(sendPak2);
ServerNet.SendPacket(socket, sendPak2);
UnityEngine.Debug.Log("向客户端发送消息，SC_PreBattle");
}
private static void ProecssMessage(object _data)
{
DP_Msg data = (DP_Msg)_data;
Log.print("ProecssMessage>>>>>>Start");
while (!data.m_bError)
{
Thread.Sleep(10);
//lock (data.m_Lock)
{
Queue <WfPacket> local_RecvQueue = data.m_RecvQueue;
Queue <WfPacket> local_SendQueue = data.m_SendQueue;
object local_Lock = data.m_Lock;
PacketHandlerMgr local_PacketHandlerMgr = data.m_PacketHandlerMgr;
Socket myClientSocket = data.clientSocket;
//Log.print("ProecssMessage>>>>>>" + local_RecvQueue.Count.ToString());
try
{
//通过clientSocket接收数据
//lock (local_Lock)
{
while (local_RecvQueue.Count > 0)
{
WfPacket packet = local_RecvQueue.Dequeue();
local_PacketHandlerMgr.ProcessPacket(data, packet);
}
}
}
catch (Exception ex)
{
Log.print(ex.Message);
myClientSocket.Shutdown(SocketShutdown.Both);
myClientSocket.Close();
break;
}
}
}
Log.print("线程{0}ProecssMessage结束。", data.clientSocket.RemoteEndPoint.ToString());
}
public void ProcessPacket(DP_Msg socket, WfPacket packet)
{
ushort msgType = 0;
ushort msgLength = 0;
packet.ReadHeader(ref msgType, ref msgLength);
if (ServerNet.GetEnableDebug())
{
Debug.Log("receiving:" + msgType);
}
System.Action <DP_Msg, WfPacket> handler = null;
if (!m_PacketHandlers.TryGetValue(msgType, out handler))
{
try
{
handler(socket, packet);
}
catch (Exception ex)
{
Log.print(ex.Message);
}
}
}
