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);
        }
Beispiel #2
0
        private void ReceiveCheckPackage(NetPackage mPackage)
        {
            PackageCheckResult mPackageCheckResult = Protocol3Utility.getData <PackageCheckResult> (mPackage);
            UInt16             whoId    = (UInt16)(mPackageCheckResult.NWhoOrderId >> 16);
            UInt16             nOrderId = (UInt16)(mPackageCheckResult.NWhoOrderId & 0x0000FFFF);

            //DebugSystem.Log ("Client Check: nWhoId: " + whoId + " | nOrderId: " + nOrderId);

            bool bSender = bClient ? whoId == 1 : whoId == 2;

            if (bSender)
            {
                this.mUdpPeer.SendNetPackage(mPackage);

                CheckPackageInfo mRemovePackage = null;
                if (mWaitCheckSendDic.TryGetValue(nOrderId, out mRemovePackage))
                {
                    ObjectPoolManager.Instance.mUdpFixedSizePackagePool.recycle(mRemovePackage.mPackage);
                    mRemovePackage.mPackage = null;

                    mWaitCheckSendDic.Remove(nOrderId);
                    mCheckPackagePool.recycle(mRemovePackage);
                }
                else
                {
                    DebugSystem.LogError("Client 我已经收到 Send确认包了: " + nOrderId);
                }
            }
            else
            {
                CheckPackageInfo mRemovePackage = null;
                if (mWaitCheckReceiveDic.TryGetValue(nOrderId, out mRemovePackage))
                {
                    ObjectPoolManager.Instance.mUdpFixedSizePackagePool.recycle(mRemovePackage.mPackage);
                    mRemovePackage.mPackage = null;

                    mWaitCheckReceiveDic.Remove(nOrderId);
                    mCheckPackagePool.recycle(mRemovePackage);
                }
                else
                {
                    DebugSystem.LogError("Client 我已经收到Receive确认包了: " + nOrderId);
                }
            }
        }
        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 Update(double elapsed)
        {
            lock (mWaitCheckSendDic) {
                var iter1 = mWaitCheckSendDic.GetEnumerator();
                while (iter1.MoveNext())
                {
                    CheckPackageInfo mCheckInfo = iter1.Current.Value;
                    if (mCheckInfo.mTimer.elapsed() > nReSendTime)
                    {
                        mCheckInfo.nReSendCount++;
                        if (mCheckInfo.nReSendCount > nMaxReSendCount)
                        {
                            DebugSystem.LogError("Server 发送超时");
                            break;
                        }

                        DebugSystem.LogError("Server ReSendPackage: " + iter1.Current.Key);
                        this.mUdpPeer.SendNetPackage(mCheckInfo.mPackage);
                        mCheckInfo.mTimer.restart();
                    }
                }
            }

            lock (mWaitCheckReceiveDic) {
                var iter2 = mWaitCheckReceiveDic.GetEnumerator();
                while (iter2.MoveNext())
                {
                    CheckPackageInfo mCheckInfo = iter2.Current.Value;
                    if (mCheckInfo.mTimer.elapsed() > nReSendTime)
                    {
                        mCheckInfo.nReSendCount++;
                        if (mCheckInfo.nReSendCount > nMaxReSendCount)
                        {
                            DebugSystem.LogError("Server 发送超时");
                            break;
                        }

                        DebugSystem.LogError("Server ReSend SureReceive Package: " + iter2.Current.Key);
                        this.mUdpPeer.SendNetPackage(mCheckInfo.mPackage);
                        mCheckInfo.mTimer.restart();
                    }
                }
            }
        }
Beispiel #5
0
        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);
        }
Beispiel #6
0
        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);
            }
        }