Lidgren.Network.NetConnection.QueueSendMessage C# (CSharp) Method

        internal void QueueSendMessage(NetOutgoingMessage om, int seqNr)
        {
            m_peer.VerifyNetworkThread();

            int sz = om.GetEncodedSize();
            //if (sz > m_currentMTU)
            //	m_peer.LogWarning("Message larger than MTU! Fragmentation must have failed!");

            bool connReset; // TODO: handle connection reset

            // can fit this message together with previously written to buffer?
            if (m_sendBufferWritePtr + sz > m_currentMTU)
            {
                if (m_sendBufferWritePtr > 0 && m_sendBufferNumMessages > 0)
                {
                    // previous message in buffer; send these first
                    m_peer.SendPacket(m_sendBufferWritePtr, m_remoteEndPoint, m_sendBufferNumMessages, out connReset);
                    m_statistics.PacketSent(m_sendBufferWritePtr, m_sendBufferNumMessages);
                    m_sendBufferWritePtr = 0;
                    m_sendBufferNumMessages = 0;
                }
            }

            // encode it into buffer regardless if it (now) fits within MTU or not
            m_sendBufferWritePtr = om.Encode(m_peer.m_sendBuffer, m_sendBufferWritePtr, seqNr);
            m_sendBufferNumMessages++;

            if (m_sendBufferWritePtr > m_currentMTU)
            {
                // send immediately; we're already over MTU
                m_peer.SendPacket(m_sendBufferWritePtr, m_remoteEndPoint, m_sendBufferNumMessages, out connReset);
                m_statistics.PacketSent(m_sendBufferWritePtr, m_sendBufferNumMessages);
                m_sendBufferWritePtr = 0;
                m_sendBufferNumMessages = 0;
            }
        }

        // call this regularely
        internal override void SendQueuedMessages(float now)
        {
            //
            // resends
            //
            for (int i = 0; i < m_storedMessages.Length; i++)
            {
                NetOutgoingMessage om = m_storedMessages[i].Message;
                if (om == null)
                {
                    continue;
                }

                float t = m_storedMessages[i].LastSent;
                if (t > 0 && (now - t) > m_resendDelay)
                {
                    // deduce sequence number

                    /*
                     * int startSlot = m_windowStart % m_windowSize;
                     * int seqNr = m_windowStart;
                     * while (startSlot != i)
                     * {
                     *  startSlot--;
                     *  if (startSlot < 0)
                     *      startSlot = m_windowSize - 1;
                     *  seqNr--;
                     * }
                     */

                    //m_connection.m_peer.LogVerbose("Resending due to delay #" + m_storedMessages[i].SequenceNumber + " " + om.ToString());
                    m_connection.m_statistics.MessageResent(MessageResendReason.Delay);

                    m_connection.QueueSendMessage(om, m_storedMessages[i].SequenceNumber);

                    m_storedMessages[i].LastSent = now;
                    m_storedMessages[i].NumSent++;
                }
            }

            int num = GetAllowedSends();

            if (num < 1)
            {
                return;
            }

            // queued sends
            while (m_queuedSends.Count > 0 && num > 0)
            {
                NetOutgoingMessage om;
                if (m_queuedSends.TryDequeue(out om))
                {
                    ExecuteSend(now, om);
                }
                num--;
                NetException.Assert(num == GetAllowedSends());
            }
        }