Compressed gumps [0xDD]

[arul]

5.x.x client introduces a new packet for Zlib compressed gumps.
Those gump packets are sometimes 5 times smaller then uncompressed ones.

Keep in mind if you modify the core you will lost script support here.

This requires a quite extensive core modification and you will not be able to do it without basic knowledge of C# and RunUO architecture. I cannot fully support this modification, thus if you have no clue what to do disregard this post, thanks.

The architeture of the new compressed gump packet is following:

BYTE PacketId (0xDD)
DWORD GumpSerial
DWORD GumpTypeID
DWORD X
DWORD Y
 
DWORD LengthOfTheCompressedLayout
DWORD LengthOfTheUncompressedLayout
BYTE[*] CompressedLayout
 
DWORD TextLines
DWORD LengthOfTheCompressedText
DWORD LengthOfTheUncompressedText
BYTE[*] CompressedText

First off we need to make the Zlib part of the core.

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
namespace Server
{
    public enum ZLibCompressionLevel
    {
        Z_BEST_COMPRESSION = 9,
        Z_BEST_SPEED = 1,
        Z_DEFAULT_COMPRESSION = -1,
        Z_NO_COMPRESSION = 0
    }
    public enum ZLibError
    {
        Z_BUF_ERROR = -5,
        Z_DATA_ERROR = -3,
        Z_ERRNO = -1,
        Z_MEM_ERROR = -4,
        Z_NEED_DICT = 2,
        Z_OK = 0,
        Z_STREAM_END = 1,
        Z_STREAM_ERROR = -2,
        Z_VERSION_ERROR = -6
    } 
    class ZLib
    {
        public ZLib()
        {
        }
        [DllImport("zlib")]
        public static extern ZLibError compress(byte[] dest, ref int destLength, byte[] source, int sourceLength);
        [DllImport("zlib")]
        public static extern ZLibError compress2(byte[] dest, ref int destLength, byte[] source, int sourceLength, ZLibCompressionLevel level);
 
        [DllImport("zlib")]
        public static extern ZLibError uncompress(byte[] dest, ref int destLen, byte[] source, int sourceLen);
    }
}

Now, we want to have ability to send both compressed and uncompressed gump depending on the client version.
To do that, open Packets.cs and put in this interface.

public interface IGumpPacket
{
void AppendLayout (bool val);
void AppendLayout (int val);
void AppendLayout (byte[] buffer);
void AppendLayoutNS (int val);
int TextEntries { get; set; }
int Switches { get; set; }
}

Now find the definition of DisplayGumpFast packet and let it inhert the new interface

    public sealed class DisplayGumpFast : Packet, IGumpPacket

Easy, isn't it ?

Now the time has come to assembly all new packet, let's call it DisplayCompressedGumpFast.

public sealed class DisplayCompressedGumpFast : Packet, IGumpPacket
{
static DisplayCompressedGumpFast()
     {
          m_True = Gump.StringToBuffer(" 1");
          m_False = Gump.StringToBuffer(" 0");
          m_Buffer = new byte[0x400]; 
   m_Buffer[0] = 0x20;
}

public DisplayCompressedGumpFast(Gump g)
          : base(0xDD)
     {
          m_Layout = newPacketWriter();
          m_Text = newPacketWriter();
          EnsureCapacity(0x400);
          m_Stream.Write(g.Serial);
          m_Stream.Write(g.TypeID);
          m_Stream.Write(g.X);
          m_Stream.Write(g.Y);
     }
 
public void AppendLayout(bool val)
     {
          AppendLayout(val ? m_True : m_False);
     }
 
public void AppendLayout(int val)
     {
   string text = val.ToString();
   int num = System.Text.Encoding.ASCII.GetBytes(text, 0, text.Length, m_Buffer, 1) + 1;
          m_Layout.Write(m_Buffer, 0, num);
          m_LayoutLength += num;
     }
 
public void AppendLayout(byte[] buffer)
     {
   int num = buffer.Length;
          m_Layout.Write(buffer, 0, num);
          m_LayoutLength += num;
     }
 
public void AppendLayoutNS(int val)
     {
   string text = val.ToString();
   int num = System.Text.Encoding.ASCII.GetBytes(text, 0, text.Length, m_Buffer, 1);
          m_Layout.Write(m_Buffer, 1, num);
          m_LayoutLength += num;
     }
 
public void Output()
     {
byte[] buffer = new byte[BufferSize];
   int length = buffer.Length;
 

   if (
        ZLib.compress2(
                    buffer,
             ref length,
                    m_Layout.ToArray(),
                    m_LayoutLength,
             ZLibCompressionLevel.Z_BEST_SPEED) == ZLibError.Z_OK
               )
               {
 
                    WriteBuffer(
                    buffer, 
             ref length, 
                    m_LayoutLength
                    );
 

        if (
        ZLib.compress2(
                    buffer,
             ref length,
                    m_Text.ToArray(),
                    m_TextLength,
             ZLibCompressionLevel.Z_BEST_SPEED) == ZLibError.Z_OK
                    )
               {
 
                    m_Stream.Write(m_TextLines);

             WriteBuffer(
                    buffer, 
             ref length, 
                    m_TextLength
                    );

       }
          }
     }
 
public void WriteBuffer(byte[] buffer, refint length, int contentLength)
     {
         m_Stream.Write(length + 4); 
  m_Stream.Write(contentLength);
  m_Stream.Write(buffer, 0, length); 
  length = buffer.Length; 
}
 
public void WriteText(ArrayList text)
     {
          m_TextLines = text.Count; 
 
   for (int i = 0; i < text.Count; ++i)
          {
        string v = (string)text[i];
if (v == null)
                    v = "";
 

int length = v.Length;

               m_TextLength += length * 2;
               m_Text.Write((ushort)length);
               m_Text.WriteBigUniFixed(v, length);
          }
 
          m_TextLength += text.Count * 2;
     }
 
public int Switches
     {
  get
  {
        return this.m_Switches;
         }
 
  set
  {
        this.m_Switches = value;
         }
     }
 
public int TextEntries
     {
   get
   {
        return this.m_TextEntries;
          }
 
   set
   {
        this.m_TextEntries = value;
          }
     }
 
private static byte[] m_Buffer;
 
private static byte[] m_False;
private static byte[] m_True;
private const ushort BufferSize = 0x2000;
private int m_LayoutLength;
private int m_Switches;
private int m_TextEntries;
private int m_TextLength;
private int m_TextLines;
private PacketWriter m_Layout;
private PacketWriter m_Text;
}

Okay, it's a search&replace job till now.

Open Gumps/Gump.cs and edit SendTo method:

public void SendTo( NetState state )
    {
          state.AddGump( this );
    if (state.Version != null && state.Version.Major >= 5)
          {
               state.Send(CompileCompressed());
          }
   else
   {
               state.Send(Compile());
          }
     }

Now add a new method to the Gump class

private Packet CompileCompressed()
     {
  if (m_Packet == null)
          {
DisplayCompressedGumpFast disp = new DisplayCompressedGumpFast(this);
       if (!m_Dragable)
               {
                    disp.AppendLayout(m_NoMove);
               }
       if (!m_Closable)
               {
                    disp.AppendLayout(m_NoClose);
               }
       if (!m_Disposable)
               {
                    disp.AppendLayout(m_NoDispose);
               }
       if (!m_Resizable)
               {
                    disp.AppendLayout(m_NoResize);
               }
 
       int entries = m_Entries.Count;

       for (int i = 0; i < entries; i++)
               {
GumpEntry entry = (GumpEntry)this.m_Entries[i];
                    disp.AppendLayout(m_BeginLayout);
                    entry.AppendTo(disp);
                    disp.AppendLayout(m_EndLayout);
               }
 
               disp.WriteText(m_Strings);
 
               m_TextEntries = disp.TextEntries;
               m_Switches = disp.Switches;
 
               disp.Output();
 
               m_Packet = disp;
          }
 
return m_Packet;
     }

You will probably need to change the type of m_Packet variable

private Packet m_Packet;

Open GumpEntry.cs and edit AppendTo method this way

public abstract void AppendTo(IGumpPacket disp);

ok, now the most annoying part, you have to open all classes which inherts the GumpEntry class and edit the AppendTo method the similar way as above.
(edit)
the AppendTo method of the VirtueGump ( Engines/Virtues/VirtueGump.cs ) needs to be updated either.

example, GumpButton.cs

public override void AppendTo(IGumpPacket disp)
     {
          disp.AppendLayout( m_LayoutName );
          disp.AppendLayout( m_X );
          disp.AppendLayout( m_Y );
          disp.AppendLayout( m_ID1 );
          disp.AppendLayout( m_ID2 );
          disp.AppendLayout( (int)m_Type );
          disp.AppendLayout( m_Param );
          disp.AppendLayout( m_ButtonID );
     }

This should be all, if I forget to post something, let me know please, also sorry for the code format, I copied the code out of Visual Studio and it auto-formated the code so terribly

[redwolf1024]

ya i found a few things prolly becouse of the way it pasted but also small thing ya forgot

newbyte[ >> new byte[
Encoding.ASCII.GetBytes( >> System.Text. Encoding.ASCII.GetBytes(
refint >> ref int

System.Text. had to be add'd becouse the file that comes in the package
isnt using System.Text by default... :P
but looks good and works great... thx

[arul]

Thanks!
The vBulletins text parsing engine do get me down

[brodock]

using this mod everybody needs to have ML or any updated client is able to receive compressed gumps?

[arul]

Compressed gumps are sent only to client clients with 5 or higher major version number. To the rest are sent uncompressed gumps as you can see here

 public void SendTo( NetState state )
    {
    state.AddGump( this );
    if (state.Version != null && state.Version.Major >= 5)
          {
               state.Send(CompileCompressed());
          }
   else
   {
               state.Send(Compile());
          }
     }

[brodock]

thanks

[BagelMan]

There is one issue with your code - you seem to have overlooked the purpose of m_packet. It is there to cache the compiled (and in this case compressed) version of a gump. This is usefull if you have a gump that does not change based on recipient or any frequently changing variables, e.g. a Message of the Day gump. It means you can create a single gump and send it to anyone who needs it, rather than calling the constructor and compile methods every time you want to send it. For example, the code

Gump Announcement = new AnnouncementGump(message);
foreach(NetState state in NetState.Instances)
	state.Mobile.SendGump(Announcement);

is much more efficient than

foreach(NetState state in NetState.Instances)
	state.Mobile.SendGump(new AnnouncementGump(message));

Your code would create a bug, however, because it uses m_packet to cache both compressed and uncompressed packets. Therefore, if you send a gump to someone with a new client, it will cache a compressed gump. If you then send it to an old client, it will send the same compressed gump.

To remedy this I would recomend using 2 packet variables -

		private DisplayGumpFast m_Packet;
		private DisplayCompressedGumpFast m_CompressedPacket;

and using m_CompressedPacket in place of m_Packet in CompileCompressed(). In addition, extend Invalidate() to

		public void Invalidate()
		{
			if ( m_Packet != null || m_CompressedPacket != null )
			{
				m_Packet = null;
				m_CompressedPacket = null;

				if ( m_Strings.Count > 0 )
					m_Strings.Clear();
			}
		}

This should allow the same gump to be sent to both old and new clients. It may also be a good idea to enable scripts to set the desired level of compression, so that, for example, a very large message of the day gump, or any other large gump with constant appearance, can be compressed once with high compression and sent repeatedly. I'll be working on that later today.

[Jeff]

Hmm, necro....anywho i beleve 2.0 already has support for compressed gumps.

[BagelMan]

I assumed a "necro" of a 7 month old thread would be acceptable on a board that still has posts from february of last year on the first page. And since RunUO 2.0 is still reffered to as "coming soon", I thought this could still be usefull.

edit: And uppon inspection of RunUO 2.0 source, it would appear that they removed packet caching from the gump code altogether. Does anyone know why?

[HellRazor]

Originally Posted by Jeff

Hmm, necro....anywho i beleve 2.0 already has support for compressed gumps.

It's still of interest, if nothing else from an educational standpoint.