public void RecvReliablePackets(ClientTransport transport, KcpCon kcp, List <Packet> packets, ClientHeartbeatProcessing heartbeat)
        {
            while (true)
            {
                int size = kcp.Recv(m_Buffer, 0, m_Buffer.Length);

                if (size <= 0)
                {
                    break;
                }

                if (size == 8)
                {
                    ByteReadMemory memory = new ByteReadMemory(m_Buffer, 0, 8);
                    uint           flag   = memory.ReadUInt();
                    uint           conv   = memory.ReadUInt();

                    if (conv == kcp.Conv)
                    {
                        if (flag == KcpConstants.Flag_Heartbeat)
                        {
                            heartbeat.RecvHeartbeat();
                            continue;
                        }

                        if (flag == KcpConstants.Flag_Disconnect)
                        {
                            transport.Disconnect(false, true);
                            continue;
                        }
                    }
                }

                PacketProcessing.Recv(m_Buffer, 0, size, packets);
            }
        }
Beispiel #2
0
        private void OnHandleLooper(object obj)
        {
            try
            {
                List <Packet>             packets   = new List <Packet>();
                byte[]                    rawBuffer = new byte[KcpConstants.Packet_Length];
                ClientDataProcessing      process   = new ClientDataProcessing();
                ClientHeartbeatProcessing heartbeat = new ClientHeartbeatProcessing();

                while (!m_Dispose && m_Status == Status.Success)
                {
                    if (m_SendPackets.Count > 0)
                    {
                        process.SendPackets(m_Kcp, m_SendPackets);
                    }

                    long time = TimeUtils.Get1970ToNowMilliseconds();
                    m_Kcp.OnUpdate(time);
                    heartbeat.UpdateHeartbeat(this, m_Kcp, time);

                    while (m_Socket.Poll(0, SelectMode.SelectRead))
                    {
                        int count = m_Socket.Receive(rawBuffer, 0, rawBuffer.Length, SocketFlags.None);

                        if (count > KcpConstants.Head_Size)
                        {
                            uint remoteCid = KcpHelper.Decode32u(rawBuffer, 0);
                            if (remoteCid == m_Kcp.ConId)
                            {
                                byte msgChannel = rawBuffer[KcpConstants.Conv_Size];

                                if (msgChannel == MsgChannel.Reliable)
                                {
                                    m_Kcp.Input(rawBuffer, KcpConstants.Head_Size, count - KcpConstants.Head_Size);
                                    process.RecvReliablePackets(this, m_Kcp, packets, heartbeat);
                                }
                                else if (msgChannel == MsgChannel.Unreliable)
                                {
                                    process.RecvUnreliablePackets(rawBuffer, KcpConstants.Head_Size, count - KcpConstants.Head_Size, packets);
                                }

                                int length = packets.Count;
                                if (length > 0)
                                {
                                    for (int i = 0; i < length; ++i)
                                    {
                                        m_RecvPackets.Enqueue(packets[i]);
                                    }
                                    packets.Clear();
                                }
                            }
                        }
                    }

                    Thread.Sleep(5);
                }
            }
            catch (Exception e)
            {
                Logger.Error(e.ToString());
                if (m_Status == Status.Success)
                {
                    m_Status = Status.Disconnect;
                }
            }
            finally
            {
                if (!m_Dispose)
                {
                    if (m_Status == Status.Disconnect)
                    {
                        m_Register.Notify(Msg.Disconnect);
                    }
                }
            }
        }