elitepvpers
Page 1 of 2 1 2
Show 40 post(s) from this thread on one page

elitepvpers (https://www.elitepvpers.com/forum/)
-   CO2 Programming (https://www.elitepvpers.com/forum/co2-programming/)
-   -   Packetbuilder (https://www.elitepvpers.com/forum/co2-programming/1496302-packetbuilder.html)

Arco. 10/18/2011 21:21
Packetbuilder
 
I have a simple packetbuilder right now, but is there any way that this can be optimized for efficiency?
Spoiler:
Code:
class PacketBuilder
    {
        private byte[] buffer;

        public PacketBuilder(byte[] Buffer)
        {
            buffer = Buffer;
        }
        public void ZeroFill(byte[] Buffer, ushort Offset, ushort Count)
        {
            for (ushort i = 0; i < Count; i++)
                Buffer[i + Offset] = 0x00;
        }
        public void WriteStringWithLength(string Arg, ushort Offset)
        {
            buffer[Offset] = (byte)Arg.Length;
            Offset++;
            ushort i = 0;
            while (i < Arg.Length)
            {
                buffer[(ushort)(i + Offset)] = (byte)Arg[i];
                i = (ushort)(i + 1);
            }
        }
        public void WriteString(string Arg, ushort Offset)
        {
            ushort i = 0;
            while (i < Arg.Length)
            {
                buffer[(ushort)(i + Offset)] = (byte)Arg[i];
                i = (ushort)(i + 1);
            }
        }
        public void WriteUshort(ushort Arg, ushort Offset)
        {
            buffer[Offset] = (byte)(Arg);
            buffer[Offset + 1] = (byte)(Arg >> 8);
        }
        public void WriteUInt(uint Arg, ushort Offset)
        {
            buffer[Offset] = (byte)(Arg);
            buffer[Offset + 1] = (byte)(Arg >> 8);
            buffer[Offset + 2] = (byte)(Arg >> 16);
            buffer[Offset + 3] = (byte)(Arg >> 24);
        }
        public void WriteUlong(ulong Arg, ushort Offset)
        {
            buffer[Offset] = (byte)(Arg);
            buffer[Offset + 1] = (byte)(Arg >> 8);
            buffer[Offset + 2] = (byte)(Arg >> 16);
            buffer[Offset + 3] = (byte)(Arg >> 24);
            buffer[Offset + 4] = (byte)(Arg >> 32);
            buffer[Offset + 5] = (byte)(Arg >> 40);
            buffer[Offset + 6] = (byte)(Arg >> 48);
            buffer[Offset + 7] = (byte)(Arg >> 56);
        }
    }

BaussHacker 10/18/2011 21:43
Why you making Offset ushort? Just make it an int instead from ushort -> int, because index of an array is int.

buffer[int], even it doesn't say anything, it still uses time converting from ushort to int. I could be wrong, but it's how I look at it.

And this:
Code:
        public void WriteStringWithLength(string Arg, ushort Offset)
        {
            buffer[Offset] = (byte)Arg.Length;
            Offset++;
            ushort i = 0;
            while (i < Arg.Length)
            {
                buffer[(ushort)(i + Offset)] = (byte)Arg[i];
                i = (ushort)(i + 1);
            }
        }
Just use a for loop.
Code:
        public void WriteStringWithLength(string Arg, ushort Offset)
        {
            buffer[Offset] = (byte)Arg.Length;
            for (int i = 1; i < Arg.Length; i++)
                buffer[(ushort)(i + Offset)] = (byte)Arg[i];
        }
Same goes for:
Code:
public void WriteString(string Arg, ushort Offset)
        {
            ushort i = 0;
            while (i < Arg.Length)
            {
                buffer[(ushort)(i + Offset)] = (byte)Arg[i];
                i = (ushort)(i + 1);
            }
        }
Code:

        public void WriteString(string Arg, ushort Offset)
        {
            for (int i = 0; i < Arg.Length; i++)
                buffer[(ushort)(i + Offset)] = (byte)Arg[i];
        }
Can't really see much more, not even sure if it will do lot difference.

Arco. 10/18/2011 22:46
Thanks beautiful.

pro4never 10/18/2011 23:30
Few things..

Pointers. I don't see much reason not to use them here
Structs. Maybe its just me who's fond if it but I'd rather just use a memory structure that's organized the same as my packet then marshal it to send.

IAmHawtness 10/18/2011 23:35
Quote:
Originally Posted by pro4never (Post 13423344)
Few things..

Pointers. I don't see much reason not to use them here
Structs. Maybe its just me who's fond if it but I'd rather just use a memory structure that's organized the same as my packet then marshal it to send.
I agree with the pointers part, unsafe code would optimize this code a lot. All these bitwise shifts are pretty CPU intensive (as in they require a lot more cycles) compared to using pointers.

I've never been a fan of using structs though, mainly because I'm often too lazy to completely structure a packet

Korvacs 10/19/2011 00:13
Pointers, a way to write a byte to the buffer would come in handy aswell, i assume you forgot about that..

Arco. 10/19/2011 01:55
So how do all of you write/structure packets?

Korvacs 10/19/2011 02:03
Packet class with buffer and pointer, then a series of methods to write to the buffer using the pointer etc.

Arco. 10/19/2011 02:21
Sorta long the lines of this?
Code:
        public static void WriteUInt32(uint arg, int offset, byte[] buffer)
        {
            unsafe
            {
                fixed (byte* Buffer = buffer)
                {
                    *((uint*)(Buffer + offset)) = arg;
                }
            }
        }
Alright in case that's what you mean by it, this is what I recoded my packetbuilder to.

Spoiler:
Code:
public class Writer
{
    byte[] buffer;

    public Writer(byte[] BUFFER)
    {
        buffer = BUFFER;
    }
    public void WriteStringWithLength(string arg, int offset)
    {
        buffer[offset] = (byte)arg.Length;
        offset++;
        ushort i = 0;
        while (i < arg.Length)
        {
            buffer[(ushort)(i + offset)] = (byte)arg[i];
            i = (ushort)(i + 1);
        }
    }
    public void WriteString(string arg, int offset )
    {
        if (buffer.Length >= offset + arg.Length)
        {
            unsafe
            {
                fixed (byte* Buffer = buffer)
                {
                    ushort i = 0;
                    while (i < arg.Length)
                    {
                        *((byte*)(Buffer + offset + i)) = (byte)arg[i];
                        i++;
                    }
                }
            }
        }
    }
    public void WriteByte(byte arg, int offset )
    {
        buffer[offset] = (byte)(arg);
    }
    public void WriteUInt16(ushort arg, int offset )
    {
        if (buffer.Length >= offset + sizeof(ushort))
        {
            unsafe
            {
                fixed (byte* Buffer = buffer)
                    *((ushort*)(Buffer + offset)) = arg;
            }
        }
    }
    public void WriteUInt32(uint arg, int offset )
    {
        if (buffer.Length >= offset + sizeof(uint))
        {
            unsafe
            {
                fixed (byte* Buffer = buffer)
                    *((uint*)(Buffer + offset)) = arg;

            }
        }
    }
    public void WriteUInt64(ulong arg, int offset )
    {
        if (buffer.Length >= offset + sizeof(ulong))
        {
            unsafe
            {
                fixed (byte* Buffer = buffer)
                    *((ulong*)(Buffer + offset)) = arg;

            }
        }
    }
    public void WriteStringList(List<string> arg, int offset )
    {

        buffer[offset] = (byte)arg.Count;
        offset++;
        foreach (string str in arg)
        {
            buffer[offset] = (byte)str.Length;
            WriteString(str, offset + 1);
            offset += str.Length + 1;
        }
    }
}

pro4never 10/19/2011 03:38
I'd strongly recommend looking into tq's net string packer...

It's sexy as hell imo. You can reverse it from the eudemons binary leaked source. It's what we use in my source instead of a method like your WriteStringList method there.

Korvacs 10/19/2011 09:53
Mine doesn't require the unsafe or fixed declarations in every method, but yeah something like that.

BaussHacker 10/19/2011 11:17
Quote:
Originally Posted by Arco. (Post 13424242)
Sorta long the lines of this?
Code:
        public static void WriteUInt32(uint arg, int offset, byte[] buffer)
        {
            unsafe
            {
                fixed (byte* Buffer = buffer)
                {
                    *((uint*)(Buffer + offset)) = arg;
                }
            }
        }
Alright in case that's what you mean by it, this is what I recoded my packetbuilder to.

Spoiler:
Code:
public class Writer
{
    byte[] buffer;

    public Writer(byte[] BUFFER)
    {
        buffer = BUFFER;
    }
    public void WriteStringWithLength(string arg, int offset)
    {
        buffer[offset] = (byte)arg.Length;
        offset++;
        ushort i = 0;
        while (i < arg.Length)
        {
            buffer[(ushort)(i + offset)] = (byte)arg[i];
            i = (ushort)(i + 1);
        }
    }
    public void WriteString(string arg, int offset )
    {
        if (buffer.Length >= offset + arg.Length)
        {
            unsafe
            {
                fixed (byte* Buffer = buffer)
                {
                    ushort i = 0;
                    while (i < arg.Length)
                    {
                        *((byte*)(Buffer + offset + i)) = (byte)arg[i];
                        i++;
                    }
                }
            }
        }
    }
    public void WriteByte(byte arg, int offset )
    {
        buffer[offset] = (byte)(arg);
    }
    public void WriteUInt16(ushort arg, int offset )
    {
        if (buffer.Length >= offset + sizeof(ushort))
        {
            unsafe
            {
                fixed (byte* Buffer = buffer)
                    *((ushort*)(Buffer + offset)) = arg;
            }
        }
    }
    public void WriteUInt32(uint arg, int offset )
    {
        if (buffer.Length >= offset + sizeof(uint))
        {
            unsafe
            {
                fixed (byte* Buffer = buffer)
                    *((uint*)(Buffer + offset)) = arg;

            }
        }
    }
    public void WriteUInt64(ulong arg, int offset )
    {
        if (buffer.Length >= offset + sizeof(ulong))
        {
            unsafe
            {
                fixed (byte* Buffer = buffer)
                    *((ulong*)(Buffer + offset)) = arg;

            }
        }
    }
    public void WriteStringList(List<string> arg, int offset )
    {

        buffer[offset] = (byte)arg.Count;
        offset++;
        foreach (string str in arg)
        {
            buffer[offset] = (byte)str.Length;
            WriteString(str, offset + 1);
            offset += str.Length + 1;
        }
    }
}
Make the class unsafe, then make a pointer within the class, instead declaring it everytime you're writing an offset.
Code:
byte* m_ptr
{
get
{
fixed (byte* ptr = buffer)
return ptr;
}
}
Now you don't need to declare an unsafe/fixed everytime. I think that's what Korvacs meant.

I don't know if it could help anything, but this is my packet-builder.
Code:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ConquerServerProject.Core;

namespace ConquerServerProject.Packets
{
    public unsafe class ConquerPacket
    {
        public ConquerPacket(int Length, bool AddTQ)
        {
            if (Length > Kernel.MaxPacketSize)
                throw new Exception("Invalid Packet Length.");

            m_packet = new byte[Length + 8];

            if (AddTQ)
                Write(Kernel.ServerPrefix);
        }
        public int Length { get { return m_packet.Length; } }
        private byte* m_ptr
        {
            get
            {
                fixed (byte* ptr = m_packet)
                    return ptr;
            }
        }
        private byte[] m_packet;
        private int m_offset;

        public void Write(byte Value)
        {
            *((byte*)(m_ptr + m_offset)) = (byte)Value;
            m_offset++;
        }
        public void Write(byte[] Value)
        {
            foreach (byte b in Value)
                Write(b);
        }
        public void Write(ushort Value)
        {
            *((ushort*)(m_ptr + m_offset)) = (ushort)Value;
            m_offset += 2;
        }
        public void Write(uint Value)
        {
            *((uint*)(m_ptr + m_offset)) = (uint)Value;
            m_offset += 4;
        }
        public void Write(ulong Value)
        {
            *((uint*)(m_ptr + m_offset)) = (uint)Value;
            m_offset += 8;
        }
        public void Write(string Value)
        {
            for (int i = 0; i < Value.Length; i++)
            {
                *((byte*)(m_ptr + m_offset)) = Convert.ToByte(Value[i]);
                m_offset++;
            }
        }
        public void WriteString(string Value)
        {
            Write((byte)Value.Length);
            m_offset++;
            for (int i = 0; i < Length; i++)
            {
                *((byte*)(m_ptr + m_offset)) = Convert.ToByte(Value[i]);
                m_offset++;
            }
        }
        public void Move(int AddOffset)
        {
            m_offset += AddOffset;
        }

        public static implicit operator byte[](ConquerPacket Packet)
        {
            return Packet.m_packet;
        }
    }
}

nTL3fTy 10/19/2011 12:33
Quote:
Originally Posted by BaussHacker (Post 13425916)
...
You could also declare the pointer, and set some allocated space to it (like in COAI):
Code:
ptr = (byte*)(void*)Marshal.AllocHGlobal(size);
where size could be variable or a max packet length (1024 for example).

BaussHacker 10/19/2011 13:48
Quote:
Originally Posted by nTL3fTy (Post 13426598)
You could also declare the pointer, and set some allocated space to it (like in COAI):
Code:
ptr = (byte*)(void*)Marshal.AllocHGlobal(size);
where size could be variable or a max packet length (1024 for example).
Never knew of that. I will look up on that ;O

IAmHawtness 10/19/2011 13:48
Quote:
Originally Posted by nTL3fTy (Post 13426598)
You could also declare the pointer, and set some allocated space to it (like in COAI):
Code:
ptr = (byte*)(void*)Marshal.AllocHGlobal(size);
where size could be variable or a max packet length (1024 for example).
What would the benefit be using AllocHGlobal instead of just "new byte[1024]"? They both allocate memory on the heap, but with AllocHGlobal you have to manually deallocate the memory when you're done using it.


All times are GMT +2. The time now is 07:44.
Page 1 of 2 1 2
Show 40 post(s) from this thread on one page

Powered by vBulletin®
Copyright ©2000 - 2026, Jelsoft Enterprises Ltd.
SEO by vBSEO ©2011, Crawlability, Inc.