BrawlLib.Internal.Helpers Class Reference

Static Public Member Functions
static string	TruncateLeft (string strIn, int totalWidth)
static string	Hex (int val)
static string	Hex (long val)
static string	Hex8 (int val)
static string	Hex8 (long val)
static int	UnHex (string val)
static string	WordH (string val, int wordNum)
static string	WordB (string val, int byteNum)
static long	Float (float val)
static float	UnFloat (long val)
static long	RoundUp (long val, long factor)
static long	RoundDown (long val, long factor)
static int	FindFirst (string str, int begin, char chr)
static int	FindLast (string str, int begin, char chr)
static int	FindCount (string str, int begin, char chr)
static int[]	IndiciesOf (string str, int begin, char chr)
static int	FindFirstOf (string str, int begin, char[] chr, ref char chrFound)
static int	FindFirstIgnoreNest (string str, int begin, char chr)
static int	FindFirstOfIgnoreNest (string str, int begin, char[] chr, ref char chrFound)
static int	FindFirstNot (string str, int begin, char chr)
static int	FindFirstNotDual (string str, int begin, char chr1, char chr2)
static string	InsString (string str, string insString, int begin)
static string	DelSubstring (string str, int begin, int len)
static string	ClearWhiteSpace (string str)
static string	GetComparisonSign (long value)
static int	TabUpEvents (uint eventId)
static int	TabDownEvents (uint eventId)
static float	UnScalar (long value)

Member Function Documentation

ClearWhiteSpace()

static string BrawlLib.Internal.Helpers.ClearWhiteSpace ( string  str )

inlinestatic

        {
            int whiteSpace = FindFirstNot(str, 0, ' ');
            if (whiteSpace > 0)
            {
                str = DelSubstring(str, 0, whiteSpace);
            }
 
            whiteSpace = -1;
            for (int i = str.Length - 1; i >= 0; i--)
            {
                if (str[i] == ' ')
                {
                    whiteSpace = i;
                }
                else
                {
                    break;
                }
            }
 
            if (whiteSpace != -1)
            {
                str = DelSubstring(str, whiteSpace, str.Length - whiteSpace);
            }
 
            return str;
        }

DelSubstring()

static string BrawlLib.Internal.Helpers.DelSubstring ( string  str, int  begin, int  len  )

inlinestatic

        {
            return str.Substring(0, begin) + str.Substring(begin + len);
        }

FindCount()

static int BrawlLib.Internal.Helpers.FindCount ( string  str, int  begin, char  chr  )

inlinestatic

        {
            int x = 0;
            for (int i = begin; i < str.Length; i++)
            {
                if (str[i] == chr)
                {
                    x++;
                }
            }
 
            return x;
        }

FindFirst()

static int BrawlLib.Internal.Helpers.FindFirst ( string  str, int  begin, char  chr  )

inlinestatic

        {
            for (int i = begin; i < str.Length; i++)
            {
                if (str[i] == chr)
                {
                    return i;
                }
            }
 
            return -1;
        }

FindFirstIgnoreNest()

static int BrawlLib.Internal.Helpers.FindFirstIgnoreNest ( string  str, int  begin, char  chr  )

inlinestatic

        {
            if (chr == '(')
            {
                return FindFirst(str, begin, chr);
            }
 
            char[] searchCharacters = {chr, '(', ')'};
            char chrResult = '\0';
            int searchResult = begin;
            int nested = 0;
 
            do
            {
                if (chrResult == ')' && nested > 0)
                {
                    nested--;
                }
 
                searchResult = FindFirstOf(str, searchResult, searchCharacters, ref chrResult);
                if (chrResult == '(')
                {
                    nested++;
                }
 
                searchResult++;
            } while ((nested > 0 || chrResult != chr) && chrResult != '\0');
 
            searchResult--;
 
            return searchResult;
        }

FindFirstNot()

static int BrawlLib.Internal.Helpers.FindFirstNot ( string  str, int  begin, char  chr  )

inlinestatic

        {
            for (int i = begin; i < str.Length; i++)
            {
                if (str[i] != chr)
                {
                    return i;
                }
            }
 
            return -1;
        }

FindFirstNotDual()

static int BrawlLib.Internal.Helpers.FindFirstNotDual ( string  str, int  begin, char  chr1, char  chr2  )

inlinestatic

        {
            for (int i = begin; i < str.Length; i++)
            {
                if (str[i] != chr1 && str[i] != chr2)
                {
                    return i;
                }
            }
 
            return -1;
        }

FindFirstOf()

static int BrawlLib.Internal.Helpers.FindFirstOf ( string  str, int  begin, char[]  chr, ref char  chrFound  )

inlinestatic

        {
            int result = -1;
            chrFound = '\0';
            for (int i = 0; i < chr.Length; i++)
            {
                int temp = FindFirst(str, begin, chr[i]);
 
                if (temp != -1 && (temp < result || result == -1))
                {
                    result = temp;
                    chrFound = chr[i];
                }
            }
 
            return result;
        }

FindFirstOfIgnoreNest()

static int BrawlLib.Internal.Helpers.FindFirstOfIgnoreNest ( string  str, int  begin, char[]  chr, ref char  chrFound  )

inlinestatic

        {
            int result = -1;
            chrFound = '\0';
            for (int i = 0; i < chr.Length; i++)
            {
                int temp = FindFirstIgnoreNest(str, begin, chr[i]);
 
                if (temp != -1 && (temp < result || result == -1))
                {
                    result = temp;
                    chrFound = chr[i];
                }
            }
 
            return result;
        }

FindLast()

static int BrawlLib.Internal.Helpers.FindLast ( string  str, int  begin, char  chr  )

inlinestatic

        {
            for (int i = str.Length - 1; i >= begin; i--)
            {
                if (str[i] == chr)
                {
                    return i;
                }
            }
 
            return -1;
        }

Float()

static long BrawlLib.Internal.Helpers.Float ( float  val )

inlinestatic

        {
            if (val == 0)
            {
                return 0;
            }
 
            long sign = val >= 0 ? 0 : 8;
            long exponent = 0x7F;
            float mantissa = Math.Abs(val);
 
            if (mantissa > 1)
            {
                while (mantissa > 2)
                {
                    mantissa /= 2;
                    exponent++;
                }
            }
            else
            {
                while (mantissa < 1)
                {
                    mantissa *= 2;
                    exponent--;
                }
            }
 
            mantissa -= 1;
            mantissa *= (float) Math.Pow(2, 23);
 
            return sign * 0x10000000
                   + exponent * 0x800000
                   + (long) mantissa;
        }

GetComparisonSign()

static string BrawlLib.Internal.Helpers.GetComparisonSign ( long  value )

inlinestatic

        {
            switch (value)
            {
                case 0:  return "<";
                case 1:  return "<=";
                case 2:  return "==";
                case 3:  return "!=";
                case 4:  return ">=";
                case 5:  return ">";
                default: return "(" + value + ")";
            }
        }

Hex() [1/2]

static string BrawlLib.Internal.Helpers.Hex ( int  val )

inlinestatic

        {
            return TruncateLeft(val.ToString("X"), 8);
        }

Hex() [2/2]

static string BrawlLib.Internal.Helpers.Hex ( long  val )

inlinestatic

        {
            return TruncateLeft(val.ToString("X"), 8);
        }

Hex8() [1/2]

static string BrawlLib.Internal.Helpers.Hex8 ( int  val )

inlinestatic

        {
            return TruncateLeft(val.ToString("X"), 8).PadLeft(8, '0');
        }

Hex8() [2/2]

static string BrawlLib.Internal.Helpers.Hex8 ( long  val )

inlinestatic

        {
            return TruncateLeft(val.ToString("X"), 8).PadLeft(8, '0');
        }

IndiciesOf()

static int[] BrawlLib.Internal.Helpers.IndiciesOf ( string  str, int  begin, char  chr  )

inlinestatic

        {
            List<int> indices = new List<int>();
            for (int i = begin; i < str.Length; i++)
            {
                if (str[i] == chr)
                {
                    indices.Add(i);
                }
            }
 
            return indices.ToArray();
        }

InsString()

static string BrawlLib.Internal.Helpers.InsString ( string  str, string  insString, int  begin  )

inlinestatic

        {
            return str.Substring(0, begin) + insString + str.Substring(begin);
        }

RoundDown()

static long BrawlLib.Internal.Helpers.RoundDown ( long  val, long  factor  )

inlinestatic

        {
            return val - val % factor;
        }

RoundUp()

static long BrawlLib.Internal.Helpers.RoundUp ( long  val, long  factor  )

inlinestatic

        {
            return val + (factor - 1) - (val + (factor - 1)) % factor;
        }

TabDownEvents()

static int BrawlLib.Internal.Helpers.TabDownEvents ( uint  eventId )

inlinestatic

        {
            switch (eventId)
            {
                case 0x00050000:
                case 0x000B0100:
                case 0x000B0200:
                case 0x000B0300:
                case 0x000B0400:
                case 0x000C0100:
                case 0x000C0200:
                case 0x000C0300:
                case 0x000C0400:
                case 0x000D0200:
                case 0x000D0400:
                case 0x000E0000:
                case 0x000F0000:
                case 0x00110100:
                case 0x00120000:
                case 0x00130000:
                    return 1;
                default:
                    return 0;
            }
        }

TabUpEvents()

static int BrawlLib.Internal.Helpers.TabUpEvents ( uint  eventId )

inlinestatic

        {
            switch (eventId)
            {
                case 0x00040100:
                case 0x000A0100:
                case 0x000A0200:
                case 0x000A0300:
                case 0x000A0400:
                case 0x000B0100:
                case 0x000B0200:
                case 0x000B0300:
                case 0x000B0400:
                case 0x000C0100:
                case 0x000C0200:
                case 0x000C0300:
                case 0x000C0400:
                case 0x000D0200:
                case 0x000D0400:
                case 0x000E0000:
                case 0x00100200:
                case 0x00110100:
                case 0x00120000:
                    return 1;
                default:
                    return 0;
            }
        }

TruncateLeft()

static string BrawlLib.Internal.Helpers.TruncateLeft ( string  strIn, int  totalWidth  )

inlinestatic

        {
            if (totalWidth <= 0)
            {
                return "";
            }
 
            if (totalWidth > strIn.Length)
            {
                return strIn;
            }
 
            return strIn.Substring(strIn.Length - totalWidth);
        }

UnFloat()

static float BrawlLib.Internal.Helpers.UnFloat ( long  val )

inlinestatic

        {
            if (val == 0)
            {
                return 0;
            }
 
            float sign = (val & 0x80000000) == 0 ? 1 : -1;
            int exponent = (int) (val & 0x7F800000) / 0x800000 - 0x7F;
            float mantissa = val & 0x7FFFFF;
            long mantissaBits = 23;
 
            if (mantissa != 0)
            {
                while (((long) mantissa & 0x1) != 1)
                {
                    mantissa /= 2;
                    mantissaBits--;
                }
            }
 
            mantissa /= (float) Math.Pow(2, mantissaBits);
            mantissa += 1;
 
            mantissa *= (float) Math.Pow(2, exponent);
            return mantissa *= sign;
        }

UnHex()

static int BrawlLib.Internal.Helpers.UnHex ( string  val )

inlinestatic

        {
            return int.Parse(val, System.Globalization.NumberStyles.HexNumber);
        }

UnScalar()

static float BrawlLib.Internal.Helpers.UnScalar ( long  value )

inlinestatic

        {
            return (float) value / 60000f;
        }

WordB()

static string BrawlLib.Internal.Helpers.WordB ( string  val, int  byteNum  )

inlinestatic

        {
            if (byteNum >= 4)
            {
                return "";
            }
 
            return TruncateLeft(val, 8).PadLeft(8, '0').Substring(byteNum * 2, 2);
        }

WordH()

static string BrawlLib.Internal.Helpers.WordH ( string  val, int  wordNum  )

inlinestatic

        {
            if (wordNum >= 2)
            {
                return "";
            }
 
            return TruncateLeft(val, 8).PadLeft(8, '0').Substring(wordNum * 4, 4);
        }

---

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

• BrawlLib/Internal/Helpers.cs