Handles outgoing packet compression for the network.
Exemplo n.º 1
0
        private void InternalCompile(bool compress)
        {
            if (m_Length == 0)
            {
                long streamLen = m_Stream.Length;

                m_Stream.Seek(1, SeekOrigin.Begin);
                m_Stream.Write((ushort)streamLen);
            }
            else if (m_Stream.Length != m_Length)
            {
                int diff = (int)m_Stream.Length - m_Length;

                Console.WriteLine("Packet: 0x{0:X2}: Bad packet length! ({1}{2} bytes)", PacketID, diff >= 0 ? "+" : "",
                                  diff);
            }

            MemoryStream ms = m_Stream.UnderlyingStream;

            m_CompiledBuffer = ms.GetBuffer();
            int length = (int)ms.Length;

            if (compress)
            {
                byte[] buffer = ArrayPool <byte> .Shared.Rent(CompressorBufferSize);

                Compression.Compress(m_CompiledBuffer, 0, length, buffer, out length);

                if (length <= 0)
                {
                    Console.WriteLine("Warning: Compression buffer overflowed on packet 0x{0:X2} ('{1}') (length={2})",
                                      PacketID, GetType().Name, length);
                    using StreamWriter op = new StreamWriter("compression_overflow.log", true);
                    op.WriteLine("{0} Warning: Compression buffer overflowed on packet 0x{1:X2} ('{2}') (length={3})",
                                 DateTime.UtcNow, PacketID, GetType().Name, length);
                    op.WriteLine(new StackTrace());
                }
                else
                {
                    m_CompiledLength = length;

                    if ((m_State & State.Static) != 0)
                    {
                        m_CompiledBuffer = new byte[length];
                        Buffer.BlockCopy(buffer, 0, m_CompiledBuffer, 0, length);
                        ArrayPool <byte> .Shared.Return(buffer);
                    }
                    else
                    {
                        m_CompiledBuffer = buffer;
                        m_State         |= State.Buffered;
                    }
                }
            }
            else if (length > 0)
            {
                byte[] old = m_CompiledBuffer;
                m_CompiledLength = length;

                if ((m_State & State.Static) != 0)
                {
                    m_CompiledBuffer = new byte[length];
                }
                else
                {
                    m_CompiledBuffer = ArrayPool <byte> .Shared.Rent(length);

                    m_State |= State.Buffered;
                }

                Buffer.BlockCopy(old, 0, m_CompiledBuffer, 0, length);
            }

            PacketWriter.ReleaseInstance(m_Stream);
            m_Stream = null;
        }