BrawlLib.Wii.MSBinDecoder Class Reference

Static Public Member Functions
static int	EncodeString (string s, byte *dPtr)
static int	GetStringSize (string s)

Member Function Documentation

EncodeString()

static int BrawlLib.Wii.MSBinDecoder.EncodeString ( string  s, byte *  dPtr  )

inlinestatic

        {
            if (s.Length == 0)
            {
                return 0;
            }
 
            int bLen;
            char c;
 
            int colorIndex, sizeIndex;
            byte* buffer = stackalloc byte[1024];
            byte* first = dPtr;
 
            byte[] utf8;
            fixed (char* p = s)
            {
                utf8 = new byte[Encoding.UTF8.GetEncoder().GetByteCount(p, s.Length, true)];
                bool completed;
                fixed (byte* b = utf8)
                {
                    Encoding.UTF8.GetEncoder().Convert(p, s.Length, b, utf8.Length, true,
                        out int charsUsed, out int bytesUsed, out completed);
                }
 
                if (!completed)
                {
                    throw new Exception("Could not encode the MSBin file.");
                }
            }
 
            // The loop below is ignorant of UTF8, but it looks for certain ASCII characters and writes each character as 1 byte, so hopefully this kludge will make it work
            char[] utf8_to_char_array = new char[utf8.Length];
            for (int i = 0; i < utf8.Length; i++)
            {
                utf8_to_char_array[i] = (char) utf8[i];
            }
 
            fixed (char* p = utf8_to_char_array)
            {
                char* sPtr = p, ceil = sPtr + utf8_to_char_array.Length;
 
                while (sPtr < ceil)
                {
                    c = *sPtr++;
                    if (c == '<')
                    {
                        char* last = sPtr;
                        byte* tPtr = buffer;
                        while (last < ceil && (c = *last++) != '>')
                        {
                            if (c != ' ')
                            {
                                *tPtr++ = (byte) c;
                            }
                        }
 
                        if (c != '>')
                        {
                            *dPtr++ = (byte) '<';
                        }
                        else
                        {
                            sPtr = last;
                            bLen = (int) tPtr - (int) buffer;
                            ToLower(buffer, bLen);
 
                            byte* control = dPtr;
                            byte* flag = dPtr + 1;
                            byte* data = dPtr + 2;
 
                            if ((sizeIndex = IndexOf(buffer, bLen, "size=")) >= 0)
                            {
                                *control = 0x12;
                                *flag |= 1;
                                *data++ = 0x0D;
 
                                tPtr = buffer + sizeIndex + 5;
                                ReadHex(ref data, ref tPtr, 2);
 
                                dPtr = data;
                            }
 
                            if ((colorIndex = IndexOf(buffer, bLen, "color=")) >= 0)
                            {
                                *control = 0x12;
                                *flag |= 2;
                                *data++ = 0x0C;
 
                                tPtr = buffer + colorIndex + 6;
                                ReadHex(ref data, ref tPtr, 4);
 
                                dPtr = data;
                            }
 
                            if (StrContains(buffer, bLen, "end"))
                            {
                                *dPtr++ = 0x13;
                            }
                        }
                    }
                    else if (c == '[')
                    {
                        char* last = sPtr;
                        byte* tPtr = buffer;
                        while (last < ceil && (c = *last++) != ']')
                        {
                            if (c != ' ')
                            {
                                *tPtr++ = (byte) c;
                            }
                        }
 
                        if (c != ']')
                        {
                            *dPtr++ = (byte) ']';
                        }
                        else
                        {
                            sPtr = last;
                            bLen = (int) tPtr - (int) buffer;
                            ToLower(buffer, bLen);
 
                            if ((colorIndex = IndexOf(buffer, bLen, "border=")) >= 0)
                            {
                                tPtr = buffer + colorIndex + 7;
 
                                *dPtr++ = 0x11;
                                ReadHex(ref dPtr, ref tPtr, 4);
                            }
                        }
                    }
                    else if (c == '\\')
                    {
                        if (sPtr < ceil)
                        {
                            *dPtr++ = (byte) *sPtr++;
                        }
                    }
                    else if (c == '\r')
                    {
                    } //do nothing
                    else
                    {
                        *dPtr++ = (byte) c;
                    }
                }
            }
 
            return (int) dPtr - (int) first;
        }

GetStringSize()

static int BrawlLib.Wii.MSBinDecoder.GetStringSize ( string  s )

inlinestatic

        {
            if (s.Length == 0)
            {
                return 0;
            }
 
            int len = 0, bLen;
            int strlen = s.Length;
            char c;
 
            bool hasColor, hasSize;
            byte* buffer = stackalloc byte[1024];
 
            byte[] utf8;
            fixed (char* p = s)
            {
                utf8 = new byte[Encoding.UTF8.GetEncoder().GetByteCount(p, s.Length, true)];
                bool completed;
                fixed (byte* b = utf8)
                {
                    Encoding.UTF8.GetEncoder().Convert(p, s.Length, b, utf8.Length, true,
                        out int charsUsed, out int bytesUsed, out completed);
                }
 
                if (!completed)
                {
                    throw new Exception("Could not encode the MSBin file.");
                }
            }
 
            // The loop below is ignorant of UTF8, but it looks for certain ASCII characters and writes each character as 1 byte, so hopefully this kludge will make it work
            char[] utf8_to_char_array = new char[utf8.Length];
            for (int i = 0; i < utf8.Length; i++)
            {
                utf8_to_char_array[i] = (char) utf8[i];
            }
 
            fixed (char* p = utf8_to_char_array)
            {
                char* sPtr = p, ceil = sPtr + utf8_to_char_array.Length;
 
                while (sPtr < ceil)
                {
                    c = *sPtr++;
                    if (c == '<')
                    {
                        char* last = sPtr;
                        byte* tPtr = buffer;
                        while (last < ceil && (c = *last++) != '>')
                        {
                            if (c != ' ')
                            {
                                *tPtr++ = (byte) c;
                            }
                        }
 
                        if (c != '>')
                        {
                            len++;
                        }
                        else
                        {
                            sPtr = last;
                            bLen = (int) tPtr - (int) buffer;
                            ToLower(buffer, bLen);
 
                            if (hasColor = StrContains(buffer, bLen, "color="))
                            {
                                len += 5;
                            }
 
                            if (hasSize = StrContains(buffer, bLen, "size="))
                            {
                                len += 3;
                            }
 
                            if (hasSize || hasColor)
                            {
                                len += 2;
                            }
 
                            if (StrContains(buffer, bLen, "end"))
                            {
                                len++;
                            }
                        }
                    }
                    else if (c == '[')
                    {
                        char* last = sPtr;
                        byte* tPtr = buffer;
                        while (last < ceil && (c = *last++) != ']')
                        {
                            if (c != ' ')
                            {
                                *tPtr++ = (byte) c;
                            }
                        }
 
                        if (c != ']')
                        {
                            len++;
                        }
                        else
                        {
                            sPtr = last;
                            bLen = (int) tPtr - (int) buffer;
                            ToLower(buffer, bLen);
 
                            if (StrContains(buffer, bLen, "border="))
                            {
                                len += 5;
                            }
                        }
                    }
                    else if (c == '\\')
                    {
                        if (sPtr < ceil)
                        {
                            sPtr++;
                            len++;
                        }
                    }
                    else if (c == '\r')
                    {
                    } //do nothing
                    else
                    {
                        len++;
                    }
                }
            }
 
            return len;
        }

---

The documentation for this class was generated from the following file:

• BrawlLib/Wii/MSBinDecoder.cs