private void CheckReceivePackageLoss(NetUdpFixedSizePackage mPackage)
{
if (mPackage.nOrderId == nCurrentWaitReceiveOrderId)
{
CheckCombinePackage(mPackage);
AddReceivePackageOrderId();
while (mReceiveLossPackageDic.Count > 0)
{
if (mReceiveLossPackageDic.ContainsKey(nCurrentWaitReceiveOrderId))
{
mPackage = mReceiveLossPackageDic [nCurrentWaitReceiveOrderId];
mReceiveLossPackageDic.Remove(nCurrentWaitReceiveOrderId);
CheckCombinePackage(mPackage);
AddReceivePackageOrderId();
}
else
{
break;
}
}
}
else if (mPackage.nOrderId > nCurrentWaitReceiveOrderId)
{
mReceiveLossPackageDic [mPackage.nOrderId] = mPackage;
DebugSystem.Log("Client loss Pcakge: " + nCurrentWaitReceiveOrderId + " | " + mPackage.nOrderId);
}
else
{
DebugSystem.LogError("Client 接受 过去的 废物包： " + mPackage.nOrderId);
}
}
private void CheckCombinePackage(NetUdpFixedSizePackage mPackage)
{
if (mPackage.nGroupCount > 1)
{
NetCombinePackage cc = ObjectPoolManager.Instance.mCombinePackagePool.Pop();
cc.Init(mPackage);
mReceiveGroupList.Enqueue(cc);
}
else
{
if (mReceiveGroupList.Count > 0)
{
var currentGroup = mReceiveGroupList.Peek();
currentGroup.Add(mPackage);
if (currentGroup.CheckCombineFinish())
{
mUdpPeer.AddLogicHandleQueue(mReceiveGroupList.Dequeue());
}
}
else
{
mUdpPeer.AddLogicHandleQueue(mPackage);
}
}
}
public void Add(NetUdpFixedSizePackage mPackage)
{
Combine(mPackage);
nGetCombineCount++;
ObjectPoolManager.Instance.mUdpFixedSizePackagePool.recycle(mPackage);
}
private void Combine(NetUdpFixedSizePackage mPackage)
{
int nCopyLength = mPackage.Length - ClientConfig.nUdpPackageFixedHeadSize;
Array.Copy(mPackage.buffer, ClientConfig.nUdpPackageFixedHeadSize, base.buffer, base.Length, nCopyLength);
base.Length += nCopyLength;
}
private void HandleReceiveData()
{
while (!bClosed)
{
NetUdpFixedSizePackage mPackage = null;
int nHandlePackageCount = 0;
while (!mReceivePackageQueue.IsEmpty)
{
if (!mReceivePackageQueue.TryDequeue(out mPackage))
{
break;
}
ReceiveNetPackage(mPackage);
nHandlePackageCount++;
if (nHandlePackageCount > 50)
{
nHandlePackageCount = 0;
Thread.Sleep(1);
}
}
Thread.Sleep(50);
}
}
private void SendHeartBeat()
{
HeartBeat sendMsg = new HeartBeat();
NetUdpFixedSizePackage mPackage = GetUdpSystemPackage(UdpNetCommand.COMMAND_HEARTBEAT, sendMsg);
SendNetPackage(mPackage);
}
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);
}
protected void ReceiveNetPackage(NetUdpFixedSizePackage mPackage)
{
bool bSucccess = NetPackageEncryption.DeEncryption(mPackage);
if (bSucccess)
{
if (mPackage.nPackageId > 50)
{
mUdpCheckPool.ReceiveCheckPackage(mPackage);
}
else
{
NetPackageExecute(mPackage);
}
}
}
public void Init(NetUdpFixedSizePackage mPackage)
{
base.nPackageId = mPackage.nPackageId;
base.nGroupCount = mPackage.nGroupCount;
base.nOrderId = mPackage.nOrderId;
int nSumLength = base.nGroupCount * ClientConfig.nUdpPackageFixedBodySize + ClientConfig.nUdpPackageFixedHeadSize;
if (base.buffer.Length < nSumLength)
{
base.buffer = new byte[nSumLength];
}
base.Length = ClientConfig.nUdpPackageFixedHeadSize;
nGetCombineCount = 0;
Add(mPackage);
}
public static bool DeEncryption(NetUdpFixedSizePackage mPackage)
{
if (mPackage.Length < ClientConfig.nUdpPackageFixedHeadSize)
{
return(false);
}
for (int i = 0; i < 4; i++)
{
if (mPackage.buffer [i] != mCheck [i])
{
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);
}
private void ReceiveThreadUpdate()
{
while (!bClosed)
{
int length = 0;
try {
NetUdpFixedSizePackage mReceiveStream = ObjectPoolManager.Instance.mUdpFixedSizePackagePool.Pop();
length = mSocket.ReceiveFrom(mReceiveStream.buffer, 0, mReceiveStream.buffer.Length, SocketFlags.None, ref remoteEndPoint);
if (length > 0)
{
mReceiveStream.Length = length;
mReceivePackageQueue.Enqueue(mReceiveStream);
}
else
{
DebugSystem.Log("Client ReceiveLength: " + length);
ObjectPoolManager.Instance.mUdpFixedSizePackagePool.recycle(mReceiveStream);
}
} catch (SocketException e) {
if (e.SocketErrorCode == SocketError.Shutdown)
{
DebugSystem.LogWarning("Socket 接受操作被禁止");
}
else
{
DebugSystem.LogWarning("ScoketException: " + e.SocketErrorCode);
}
break;
} catch (Exception e) {
DebugSystem.LogError(e.Message);
m_state = NETSTATE.DISCONNECTED;
peer_event mEvent = new peer_event();
mEvent.mNetEventType = NETEVENT.DISCONNECTED;
mEvent.msg = e.Message;
break;
}
}
DebugSystem.LogWarning("Client ReceiveThread Safe Quit !");
}
private void AddSendCheck(NetUdpFixedSizePackage mPackage)
{
if (ClientConfig.bNeedCheckPackage)
{
UInt16 nOrderId = mPackage.nOrderId;
CheckPackageInfo mCheckInfo = mCheckPackagePool.Pop();
mCheckInfo.nReSendCount = 0;
mCheckInfo.mPackage = mPackage;
mCheckInfo.mTimer.restart();
if (!mWaitCheckSendDic.ContainsKey(nOrderId))
{
mWaitCheckSendDic.Add(nOrderId, mCheckInfo);
}
else
{
DebugSystem.LogError("Client Add SendCheck Repeated !!!" + nOrderId);
}
}
mUdpPeer.SendNetPackage(mPackage);
}
public void ReceiveCheckPackage(NetUdpFixedSizePackage mReceiveLogicPackage)
{
if (ClientConfig.bNeedCheckPackage)
{
UInt16 nOrderId = mReceiveLogicPackage.nOrderId;
PackageCheckResult mResult = new PackageCheckResult();
if (bClient)
{
mResult.NWhoOrderId = (UInt32)(2 << 16 | nOrderId);
}
else
{
mResult.NWhoOrderId = (UInt32)(1 << 16 | nOrderId);
}
NetUdpFixedSizePackage mCheckResultPackage = mUdpPeer.GetUdpSystemPackage(UdpNetCommand.COMMAND_PACKAGECHECK, mResult);
CheckPackageInfo mCheckInfo = mCheckPackagePool.Pop();
mCheckInfo.nReSendCount = 0;
mCheckInfo.mPackage = mCheckResultPackage;
mCheckInfo.mTimer.restart();
if (!mWaitCheckReceiveDic.ContainsKey(nOrderId))
{
mWaitCheckReceiveDic.Add(nOrderId, mCheckInfo);
}
mUdpPeer.SendNetPackage(mCheckResultPackage);
CheckReceivePackageLoss(mReceiveLogicPackage);
}
else
{
CheckCombinePackage(mReceiveLogicPackage);
}
}
