private void CheckReceivePackageLoss(NetUdpFixedSizePackage mPackage)
{
if (mPackage.nOrderId == nCurrentWaitReceiveOrderId)
{
CheckCombinePackage(mPackage);
AddReceivePackageOrderId();
while (!mReceiveLossPackageDic.IsEmpty)
{
NetUdpFixedSizePackage mTempPackage = null;
if (mReceiveLossPackageDic.TryRemove(nCurrentWaitReceiveOrderId, out mTempPackage))
{
CheckCombinePackage(mTempPackage);
AddReceivePackageOrderId();
}
else
{
break;
}
}
}
else if (mPackage.nOrderId > nCurrentWaitReceiveOrderId)
{
if (mReceiveLossPackageDic.TryAdd(mPackage.nOrderId, mPackage))
{
DebugSystem.LogError("Server Package Loss: " + nCurrentWaitReceiveOrderId + " | " + mPackage.nOrderId);
}
}
else
{
DebugSystem.LogError("Server 接受 过去的 废物包： " + mPackage.nOrderId);
ObjectPoolManager.Instance.mUdpFixedSizePackagePool.recycle(mPackage);
}
}
private void CheckCombinePackage(NetUdpFixedSizePackage mPackage)
{
if (mPackage.nGroupCount > 1)
{
NetCombinePackage cc = ObjectPoolManager.Instance.mCombinePackagePool.Pop();
cc.Init(mPackage);
mCombinePackageQueue.Enqueue(cc);
}
else
{
if (!mCombinePackageQueue.IsEmpty)
{
NetCombinePackage currentGroup = null;
if (mCombinePackageQueue.TryPeek(out currentGroup))
{
currentGroup.Add(mPackage);
if (currentGroup.CheckCombineFinish())
{
if (mCombinePackageQueue.TryDequeue(out currentGroup))
{
mUdpPeer.AddLogicHandleQueue(currentGroup);
}
}
}
}
else
{
mUdpPeer.AddLogicHandleQueue(mPackage);
}
}
}
private void AddSendCheck(NetUdpFixedSizePackage mPackage)
{
if (ServerConfig.bNeedCheckPackage)
{
//mPackage.nOrderId = nCurrentWaitSendOrderId;
UInt16 nOrderId = mPackage.nOrderId;
CheckPackageInfo mCheckInfo = mCheckPackagePool.Pop();
mCheckInfo.nReSendCount = 0;
mCheckInfo.mPackage = mPackage;
mCheckInfo.mTimer.restart();
if (mWaitCheckSendDic.TryAdd(nOrderId, mCheckInfo))
{
//AddSendPackageOrderId ();
}
else
{
throw new Exception("请增大循环Id 的范围，或者 减慢发包速度");
}
}
DebugSystem.Assert(mPackage.nOrderId >= ServerConfig.nUdpMinOrderId);
//DebugSystem.Log ("Server Send nOrderId: " + mPackage.nOrderId);
mUdpPeer.SendNetPackage(mPackage);
}
private void Combine(NetUdpFixedSizePackage mPackage)
{
int nCopyLength = mPackage.Length - ServerConfig.nUdpPackageFixedHeadSize;
Array.Copy(mPackage.buffer, ServerConfig.nUdpPackageFixedHeadSize, base.buffer, base.Length, nCopyLength);
base.Length += nCopyLength;
}
public void Add(NetUdpFixedSizePackage mPackage)
{
Combine(mPackage);
nGetCombineCount++;
ObjectPoolManager.Instance.mUdpFixedSizePackagePool.recycle(mPackage);
}
private void SendHeartBeat()
{
HeartBeat sendMsg = new HeartBeat();
NetUdpFixedSizePackage mPackage = GetUdpSystemPackage(UdpNetCommand.COMMAND_HEARTBEAT, sendMsg);
SendNetPackage(mPackage);
//ObjectPoolManager.Instance.mUdpFixedSizePackagePool.recycle (mPackage);
}
private void ReceiveThreadUpdate()
{
while (true)
{
int length = 0;
try {
EndPoint tempEndPoint = new IPEndPoint(IPAddress.Broadcast, 0);
NetUdpFixedSizePackage mPackage = ObjectPoolManager.Instance.mUdpFixedSizePackagePool.Pop();
length = mSocket.ReceiveFrom(mPackage.buffer, ref tempEndPoint);
mPackage.Length = length;
if (length > 0)
{
NetEndPointPackage mEndPointPackage = ObjectPoolManager.Instance.mNetEndPointPackagePool.Pop();
mEndPointPackage.mPackage = mPackage;
mEndPointPackage.mRemoteEndPoint = tempEndPoint;
mReceivePackageQueue.Enqueue(mEndPointPackage);
}
else
{
ObjectPoolManager.Instance.mUdpFixedSizePackagePool.recycle(mPackage);
DebugSystem.LogError("接受长度： " + length);
break;
}
} catch (SocketException e) {
if (e.SocketErrorCode == SocketError.Interrupted)
{
DebugSystem.LogWarning("阻塞Socket 调用已被取消");
}
else
{
DebugSystem.LogWarning("SocketException: " + e.SocketErrorCode);
}
break;
} catch (Exception e) {
DebugSystem.LogError("服务器 异常： " + e.Message + " | " + e.StackTrace);
m_state = NETSTATE.DISCONNECTED;
peer_event mEvent = new peer_event();
mEvent.mNetEventType = NETEVENT.DISCONNECTED;
mEvent.msg = e.Message;
break;
}
}
DebugSystem.LogWarning("Server ReceiveThread Safe Quit !");
}
public static void Encryption(NetUdpFixedSizePackage mPackage)
{
UInt16 nOrderId = mPackage.nOrderId;
UInt16 nGroupCount = mPackage.nGroupCount;
UInt16 nPackageId = mPackage.nPackageId;
Array.Copy(mCheck, 0, mPackage.buffer, 0, 4);
byte[] byCom = BitConverter.GetBytes(nOrderId);
Array.Copy(byCom, 0, mPackage.buffer, 4, byCom.Length);
byCom = BitConverter.GetBytes(nGroupCount);
Array.Copy(byCom, 0, mPackage.buffer, 6, byCom.Length);
byCom = BitConverter.GetBytes(nPackageId);
Array.Copy(byCom, 0, mPackage.buffer, 8, byCom.Length);
}
public void ReceiveCheckPackage(NetUdpFixedSizePackage mPackage)
{
//DebugSystem.Log ("Server ReceiveInfo: " + mPackage.nOrderId + " | " + mPackage.nGroupCount + " | " + mPackage.Length);
if (ServerConfig.bNeedCheckPackage)
{
PackageCheckResult mResult = new PackageCheckResult();
if (bClient)
{
mResult.NWhoOrderId = (UInt32)(2 << 16 | mPackage.nOrderId);
}
else
{
mResult.NWhoOrderId = (UInt32)(1 << 16 | mPackage.nOrderId);
}
NetUdpFixedSizePackage mCheckResultPackage = mUdpPeer.GetUdpSystemPackage(UdpNetCommand.COMMAND_PACKAGECHECK, mResult);
CheckPackageInfo mCheckInfo = mCheckPackagePool.Pop();
mCheckInfo.nReSendCount = 0;
mCheckInfo.mPackage = mCheckResultPackage;
mCheckInfo.mTimer.restart();
mWaitCheckReceiveDic.TryAdd(mPackage.nOrderId, mCheckInfo);
mUdpPeer.SendNetPackage(mCheckResultPackage);
CheckReceivePackageLoss(mPackage);
}
else
{
#if !Test
if (ServerConfig.IsLocalAreaNetWork)
{
if (nCurrentWaitReceiveOrderId != mPackage.nOrderId)
{
DebugSystem.LogError("服务器端 丢包： " + mUdpPeer.getPort() + " | " + nCurrentWaitReceiveOrderId);
}
else
{
AddReceivePackageOrderId();
}
}
#endif
CheckCombinePackage(mPackage);
}
}
public void Init(NetUdpFixedSizePackage mPackage)
{
base.nPackageId = mPackage.nPackageId;
base.nGroupCount = mPackage.nGroupCount;
base.nOrderId = mPackage.nOrderId;
int nSumLength = base.nGroupCount * ServerConfig.nUdpPackageFixedBodySize + ServerConfig.nUdpPackageFixedHeadSize;
if (base.buffer.Length < nSumLength)
{
base.buffer = new byte[nSumLength];
}
base.Length = ServerConfig.nUdpPackageFixedHeadSize;
nGetCombineCount = 0;
Add(mPackage);
}
public void SendCheckPackage(UInt16 id, byte[] buffer)
{
DebugSystem.Assert(id > 50, "Udp 系统内置命令 此逻辑不处理");
int readBytes = 0;
int nBeginIndex = 0;
UInt16 groupCount = 0;
if (buffer.Length % ServerConfig.nUdpPackageFixedBodySize == 0)
{
groupCount = (UInt16)(buffer.Length / ServerConfig.nUdpPackageFixedBodySize);
}
else
{
groupCount = (UInt16)(buffer.Length / ServerConfig.nUdpPackageFixedBodySize + 1);
}
while (nBeginIndex < buffer.Length)
{
if (nBeginIndex + ServerConfig.nUdpPackageFixedBodySize > buffer.Length)
{
readBytes = buffer.Length - nBeginIndex;
}
else
{
readBytes = ServerConfig.nUdpPackageFixedBodySize;
}
NetUdpFixedSizePackage mPackage = ObjectPoolManager.Instance.mUdpFixedSizePackagePool.Pop();
mPackage.nGroupCount = groupCount;
mPackage.nPackageId = id;
mPackage.nOrderId = nCurrentWaitSendOrderId;
mPackage.Length = readBytes + ServerConfig.nUdpPackageFixedHeadSize;
Array.Copy(buffer, nBeginIndex, mPackage.buffer, ServerConfig.nUdpPackageFixedHeadSize, readBytes);
NetPackageEncryption.Encryption(mPackage);
AddSendCheck(mPackage);
AddSendPackageOrderId();
nBeginIndex += readBytes;
groupCount = 1;
}
}
public void ReceiveUdpSocketFixedPackage(NetUdpFixedSizePackage mPackage)
{
bool bSucccess = NetPackageEncryption.DeEncryption(mPackage);
if (bSucccess)
{
if (mPackage.nPackageId > 50)
{
mUdpCheckPool.ReceiveCheckPackage(mPackage);
}
else
{
PackageManager.Instance.Execute(this as ClientPeer, mPackage);
}
}
else
{
throw new Exception("解码失败 !!!");
}
}
public static bool DeEncryption(NetUdpFixedSizePackage mPackage)
{
if (mPackage.Length < ServerConfig.nUdpPackageFixedHeadSize)
{
DebugSystem.LogError("mPackage Length： " + mPackage.Length);
return(false);
}
for (int i = 0; i < 4; i++)
{
if (mPackage.buffer [i] != mCheck [i])
{
DebugSystem.LogError("22222222222222222222222222");
return(false);
}
}
mPackage.nOrderId = BitConverter.ToUInt16(mPackage.buffer, 4);
mPackage.nGroupCount = BitConverter.ToUInt16(mPackage.buffer, 6);
mPackage.nPackageId = BitConverter.ToUInt16(mPackage.buffer, 8);
return(true);
}
