ModernUO/Projects/Server.Tests/Tests/Network/Packets/Outgoing/GumpPackets.cs

using System;
using System.Buffers;
using System.Collections.Generic;
using System.IO.Compression;
using System.Text;
using Server.Compression;
using Server.Gumps;
using Server.Network;

namespace Server.Tests
{
    public interface IGumpWriter
    {
        int TextEntries { get; set; }
        int Switches { get; set; }

        void AppendLayout(bool val);
        void AppendLayout(int val);
        void AppendLayout(uint val);
        void AppendLayout(Serial serial);
        void AppendLayoutNS(int val);
        void AppendLayout(string text);
        void AppendLayoutNS(string text);
        void AppendLayout(ReadOnlySpan<byte> buffer);
        void WriteStrings(List<string> strings);
        void Flush();
    }

    public sealed class CloseGump : Packet
    {
        public CloseGump(int typeID, int buttonID) : base(0xBF)
        {
            EnsureCapacity(13);

            Stream.Write((short)0x04);
            Stream.Write(typeID);
            Stream.Write(buttonID);
        }
    }

    public sealed class DisplayGumpPacked : Packet, IGumpWriter
    {
        private static readonly byte[] m_Buffer = new byte[48];

        private readonly Gump m_Gump;

        private readonly PacketWriter m_Layout;
        private readonly PacketWriter m_Strings;

        private int m_StringCount;

        static DisplayGumpPacked() => m_Buffer[0] = (byte)' ';

        public DisplayGumpPacked(Gump gump)
            : base(0xDD)
        {
            m_Gump = gump;

            m_Layout = PacketWriter.CreateInstance(8192);
            m_Strings = PacketWriter.CreateInstance(8192);
        }

        public int TextEntries { get; set; }

        public int Switches { get; set; }

        public void AppendLayout(bool val)
        {
            AppendLayout(val ? " 1"u8 : " 0"u8);
        }

        public void AppendLayout(int val)
        {
            var toString = val.ToString();
            var bytes = Encoding.ASCII.GetBytes(toString, 0, toString.Length, m_Buffer, 1) + 1;

            m_Layout.Write(m_Buffer, 0, bytes);
        }

        public void AppendLayout(uint val)
        {
            var toString = val.ToString();
            var bytes = Encoding.ASCII.GetBytes(toString, 0, toString.Length, m_Buffer, 1) + 1;

            m_Layout.Write(m_Buffer, 0, bytes);
        }

        public void AppendLayout(Serial serial) => AppendLayout(serial.Value);

        public void AppendLayoutNS(int val)
        {
            var toString = val.ToString();
            var bytes = Encoding.ASCII.GetBytes(toString, 0, toString.Length, m_Buffer, 1);

            m_Layout.Write(m_Buffer, 1, bytes);
        }

        public void AppendLayoutNS(string text)
        {
            m_Layout.WriteAsciiFixed(text, text.Length);
        }

        public void AppendLayout(string text)
        {
            AppendLayout(" @"u8);

            m_Layout.WriteAsciiFixed(text, text.Length);

            AppendLayout("@"u8);
        }

        public void AppendLayout(ReadOnlySpan<byte> buffer)
        {
            m_Layout.Write(buffer);
        }

        public void WriteStrings(List<string> strings)
        {
            m_StringCount = strings.Count;

            for (var i = 0; i < strings.Count; ++i)
            {
                var v = strings[i] ?? "";

                m_Strings.Write((ushort)v.Length);
                m_Strings.WriteBigUniFixed(v, v.Length);
            }
        }

        public void Flush()
        {
            EnsureCapacity(28 + (int)m_Layout.Length + (int)m_Strings.Length);

            Stream.Write(m_Gump.Serial);
            Stream.Write(m_Gump.TypeID);
            Stream.Write(m_Gump.X);
            Stream.Write(m_Gump.Y);

            // Note: layout MUST be null terminated (don't listen to krrios)
            m_Layout.Write((byte)0);

            WritePacked(m_Layout);

            Stream.Write(m_StringCount);

            WritePacked(m_Strings);

            PacketWriter.ReleaseInstance(m_Layout);
            PacketWriter.ReleaseInstance(m_Strings);
        }

        private void WritePacked(PacketWriter src)
        {
            var buffer = src.UnderlyingStream.GetBuffer();
            var length = (int)src.Length;

            if (length == 0)
            {
                Stream.Write(0);
                return;
            }

            var wantLength = 1 + length * 1024 / 1000;

            wantLength += 4095;
            wantLength &= ~4095;

            var packBuffer = ArrayPool<byte>.Shared.Rent(wantLength);
            var bytesPacked = Deflate.Standard.Pack(packBuffer, buffer.AsSpan(0, length));

            Stream.Write(4 + bytesPacked);
            Stream.Write(length);
            Stream.Write(packBuffer, 0, bytesPacked);

            ArrayPool<byte>.Shared.Return(packBuffer);
        }
    }

    public sealed class DisplaySignGump : Packet
    {
        public DisplaySignGump(Serial serial, int gumpID, string unknown, string caption) : base(0x8B)
        {
            unknown ??= "";
            caption ??= "";

            EnsureCapacity(15 + unknown.Length + caption.Length);

            Stream.Write(serial);
            Stream.Write((short)gumpID);
            Stream.Write((short)(unknown.Length + 1));
            Stream.WriteAsciiNull(unknown);
            Stream.Write((short)(caption.Length + 1));
            Stream.WriteAsciiNull(caption);
        }
    }
}