(Released, 1.13, C#) RPC To Make A Menu For MP and ZM (Stabl

//===================================================================================================//
//                                 BO1 1.13 RPC By: CrEaTiiOn_420                                    //
//===================================================================================================//
// IF You Like My RPC Then Check Out My Thread And Give Me A Thanks Also If You Have Problems Then Just Post Your Question On The Thread Also -----> http://www.nextgenupdate.com/forums/black-ops-mods-patches-tutorials/770811-released-1-13-c-rpc-make-menu-mp-zm-stable-works.html
//===================================================================================================//
//         Also Check Out My New Channel <3--------> http://youtube.com/CrEaTiiOn420OG               //
//===================================================================================================//


public class RPC
    {
        public static UInt32 function_address = 0x6E34E0; //MP = 0x7A21E0  ||  ZM = 0x6E34E0

        public static void Enable_RPC()
        {
            PS3.SetMemory(function_address, new byte[] { 0x4e, 0x80, 0, 0x20 });
            System.Threading.Thread.Sleep(20);
            byte[] memory = new byte[] {
            0x7c, 8, 2, 0xa6, 0xf8, 1, 0, 0x80, 60, 0x60, 0x10, 5, 0x81, 0x83, 0, 0x4c,
            0x2c, 12, 0, 0, 0x41, 130, 0, 100, 0x80, 0x83, 0, 4, 0x80, 0xa3, 0, 8,
            0x80, 0xc3, 0, 12, 0x80, 0xe3, 0, 0x10, 0x81, 3, 0, 20, 0x81, 0x23, 0, 0x18,
            0x81, 0x43, 0, 0x1c, 0x81, 0x63, 0, 0x20, 0xc0, 0x23, 0, 0x24, 0xc0, 0x43, 0, 40,
            0xc0, 0x63, 0, 0x2c, 0xc0, 0x83, 0, 0x30, 0xc0, 0xa3, 0, 0x34, 0xc0, 0xc3, 0, 0x38,
            0xc0, 0xe3, 0, 60, 0xc1, 3, 0, 0x40, 0xc1, 0x23, 0, 0x48, 0x80, 0x63, 0, 0,
            0x7d, 0x89, 3, 0xa6, 0x4e, 0x80, 4, 0x21, 60, 0x80, 0x10, 5, 0x38, 160, 0, 0,
            0x90, 0xa4, 0, 0x4c, 0x90, 100, 0, 80, 0xe8, 1, 0, 0x80, 0x7c, 8, 3, 0xa6,
            0x38, 0x21, 0, 0x70, 0x4e, 0x80, 0, 0x20
         };
            PS3.SetMemory(function_address + 4, memory);
            PS3.SetMemory(0x10050000, new byte[0x2854]);
            PS3.SetMemory(function_address, new byte[] { 0xf8, 0x21, 0xff, 0x91 });
        }

        public static uint Call(uint func_address, params object[] parameters)
        {
            int length = parameters.Length;
            uint num2 = 0;
            for (uint i = 0; i < length; i++)
            {
                if (parameters[i] is int)
                {
                    byte[] array = BitConverter.GetBytes((int)parameters[i]);
                    Array.Reverse(array);
                    PS3.SetMemory(0x10050000 + ((i + num2) * 4), array);
                }
                else if (parameters[i] is uint)
                {
                    byte[] buffer2 = BitConverter.GetBytes((uint)parameters[i]);
                    Array.Reverse(buffer2);
                    PS3.SetMemory(0x10050000 + ((i + num2) * 4), buffer2);
                }
                else if (parameters[i] is string)
                {
                    byte[] buffer3 = Encoding.UTF8.GetBytes(Convert.ToString(parameters[i]) + "\0");
                    PS3.SetMemory(0x10050054 + (i * 0x400), buffer3);
                    uint num4 = 0x10050054 + (i * 0x400);
                    byte[] buffer4 = BitConverter.GetBytes(num4);
                    Array.Reverse(buffer4);
                    PS3.SetMemory(0x10050000 + ((i + num2) * 4), buffer4);
                }
                else if (parameters[i] is float)
                {
                    num2++;
                    byte[] buffer5 = BitConverter.GetBytes((float)parameters[i]);
                    Array.Reverse(buffer5);
                    PS3.SetMemory(0x10050024 + ((num2 - 1) * 4), buffer5);
                }
            }
            byte[] bytes = BitConverter.GetBytes(func_address);
            Array.Reverse(bytes);
            PS3.SetMemory(0x1005004c, bytes);
            System.Threading.Thread.Sleep(20);
            byte[] memory = new byte[4];
            PS3.GetMemoryR(0x10050050, ref memory);
            Array.Reverse(memory);
            return BitConverter.ToUInt32(memory, 0);
        }
    }

//Hud Elements
//============

public class Huds
        {
            public class HudStruct
            {
                public static uint
                    G_HudElems = 0x00EE7B84,
                IndexSize = 0x84,
                x = 0x0,
                y = 0x4,
                z = 0x8,
                fontScaleStartTime = 0x14,
                fontScale = 0xC,
                entNum = 0x18,
                color = 0x18,
                teamNum = 0x1C,
                fromColor = 0x1C,
                icon = 0x20,
                fadeStartTime = 0x20,
                scaleStartTime = 0x24,
                fromX = 0x28,
                fromY = 0x2C,
                moveStartTime = 0x30,
                time = 0x34,
                duration = 0x38,
                value = 0x3C,
                sort = 0x40,
                glowColor = 0x44,
                fxBirthTime = 0x48,
                targetEntNum = 0x4C,
                fontScaleTime = 0x4E,
                fadeTime = 0x50,
                label = 0x52,
                width = 0x54,
                height = 0x56,
                fromWidth = 0x58,
                fromHeight = 0x5A,
                scaleTime = 0x5C,
                moveTime = 0x5E,
                text = 0x60,
                fxDecayStartTime = 0x64,
                fxDecayDuration = 0x66,
                fxRedactDecayStartTime = 0x68,
                fxRedactDecayDuration = 0x6A,
                flags = 0x6C,
                type = 0x6E,
                font = 0x6F,
                alignOrg = 0x70,
                alignScreen = 0x71,
                materialIndex = 0x72,
                fxLetterTime = 0x62,
                offscreenMaterialIdx = 0x73,
                fromAlignOrg = 0x74,
                fromAlignScreen = 0x75,
                soundID = 0x76,
                ui3dWindow = 0x77,
                clientNum = 0x78,
                team = 0x7C,
                archived = 0x80;
            }
            public static short G_LocalizedStringIndex(string Text)
            {
                return (short)RPC.Call(0x00304BA0, Text);
            }
            public static void ChangeText(UInt32 elemIndex, String Text)
            {
                PS3.Extension.WriteInt16(elemIndex + HudStruct.text, G_LocalizedStringIndex(Text));
            }
            public static uint SetText(int clientIndex, string TextString, int Font, Single FontSize, Single X, Single Y, uint align = 0, int r = 255, int g = 255, int b = 255, int a = 255, int glowr = 255, int glowg = 255, int glowb = 255, int glowa = 0)
            {
                uint text = HudElem_Alloc();
                PS3.Extension.WriteByte(text + HudStruct.type, 1);
                Funcs.WriteSingle(text + HudStruct.fontScale, FontSize);
                PS3.Extension.WriteByte(text + HudStruct.font, Convert.ToByte(Font));
                if (align != 0)
                { PS3.Extension.WriteByte(text + HudStruct.alignOrg, 5); PS3.Extension.WriteByte(text + HudStruct.alignScreen, Convert.ToByte(align)); }
                else
                { Funcs.WriteSingle(text + HudStruct.x, X); Funcs.WriteSingle(text + HudStruct.y, Y); }
                PS3.Extension.WriteInt32(text + HudStruct.clientNum, clientIndex);
                PS3.Extension.WriteInt16(text + HudStruct.text, G_LocalizedStringIndex(TextString));
                PS3.Extension.WriteBytes(text + HudStruct.color, new Byte[] { (Byte)r, (Byte)g, (Byte)b, (Byte)a });
                PS3.Extension.WriteBytes(text + HudStruct.glowColor, new Byte[] { (Byte)glowr, (Byte)glowg, (Byte)glowb, (Byte)glowa });
                PS3.Extension.WriteByte(text + HudStruct.ui3dWindow, 0xFF);
                return text;
            }
            public static uint SetShader(int clientIndex, int Material, short Width, short Height, Single X, Single Y, uint align = 0, int r = 255, int g = 255, int b = 255, int a = 255)
            {
                uint Shader = HudElem_Alloc();
                PS3.Extension.WriteByte(Shader + HudStruct.type, 4);
                PS3.Extension.WriteByte(Shader + HudStruct.materialIndex, Convert.ToByte(Material));
                PS3.Extension.WriteInt16(Shader + HudStruct.height, Height);
                PS3.Extension.WriteInt16(Shader + HudStruct.width, Width);
                if (align != 0)
                { PS3.Extension.WriteByte(Shader + HudStruct.alignOrg, 5); PS3.Extension.WriteByte(Shader + HudStruct.alignScreen, Convert.ToByte(align)); }
                else
                { Funcs.WriteSingle(Shader + HudStruct.x, X); Funcs.WriteSingle(Shader + HudStruct.y, Y); }
                PS3.Extension.WriteInt32(Shader + HudStruct.clientNum, clientIndex);
                PS3.SetMemory(Shader + HudStruct.ui3dWindow, new Byte[] { 0xFF });
                PS3.Extension.WriteBytes(Shader + HudStruct.color, new Byte[] { (Byte)r, (Byte)g, (Byte)b, (Byte)a });
                return Shader;
            }
            public static uint HudElem_Alloc()
            {
                for (uint i = 40; i < 1024; i++)
                {
                    uint Index = HudStruct.G_HudElems + (i * HudStruct.IndexSize);
                    if (PS3.Extension.ReadByte(Index + HudStruct.type) == 0)
                    {
                        PS3.Extension.WriteBytes(Index, new Byte[0x88]);
                        return Index;
                    }
                }
                return 0;
            }
            public static void DestroyElement(uint Element)
            {
                PS3.SetMemory(Element, new byte[HudStruct.IndexSize]);
            }
        }

//Buttons Monitoring
//==================

public static class Buttons
        {
            public static Int32
                L1 = 1048704,
                L2 = 72704,
                L3 = 1074003968,
                R1 = -2147483648,
                R2 = 131072,
                R3 = 536870912,
                Square = 67108864,
                Cross = 2104320,
                Crouch = 4194304,
                Prone = 8388608,
                Triangle = 8;
        }
        public static bool ButtonPressed(int client, int Button)
        {
            if (Convert.ToInt32(PS3.Extension.ReadInt32(0x11007E8 + ((uint)client * 0x1D30))) == Button)
                return true;
            else return false;
        }

//Addresses
//=========

 class Addresses
        {
            public static uint
            G_entityZM = 0xFA805C,
            G_entitySizeZM = 0x34C,
            G_clientZM = 0x010fed78,
            G_clientSizeZM = 0x1D30;
        }

//Functions
//=========

public static string GetPlayerNameForMenu(Int32 clientIndex)
            {
                String Name = PS3.Extension.ReadString(0x011008B8 + ((uint)clientIndex * 0x1d30));
                if (Name == "")
                    return "Not Connected";
                else
                    return Name;
            }

public string GetMap()
        {
            return PS3.Extension.ReadString(0x0138E1B8);
        }

public int getMapMaterialWhiteShader()
        {
            string map = GetMap();
            if (map == "zombie_theater")
            {
                return 18;
            }
            if (map == "zombie_pentagon")
            {
                return 17;
            }
            if (map == "zombie_cod5_prototype")
            {
                return 16;
            }
            if (map == "zombie_asylum")
            {
                return 16;
            }
            if (map == "zombie_swamp")
            {
                return 16;
            }
            if (map == "zombie_cod5_factory")
            {
                return 16;
            }
            if (map == "zombie_cosmodrome")
            {
                return 16;
            }
            if (map == "zombie_coast")
            {
                return 19;
            }
            if (map == "zombie_temple")
            {
                return 17;
            }
            if (map == "zombie_paris")
            {
                return 16;
            }
            else
            {
                return 0;
            }
        }

        public int getMapMaterialBlackShader()
        {
            string map = GetMap();
            if (map == "zombie_theater")
            {
                return 11;
            }
            if (map == "zombie_pentagon")
            {
                return 10;
            }
            if (map == "zombie_cod5_prototype")
            {
                return 9;
            }
            if (map == "zombie_asylum")
            {
                return 9;
            }
            if (map == "zombie_swamp")
            {
                return 9;
            }
            if (map == "zombie_cod5_factory")
            {
                return 9;
            }
            if (map == "zombie_cosmodrome")
            {
                return 9;
            }
            if (map == "zombie_coast")
            {
                return 12;
            }
            if (map == "zombie_temple")
            {
                return 10;
            }
            if (map == "zombie_paris")
            {
                return 9;
            }
            else
            {
                return 0;
            }
        }

        public static int GetHost()
        {
            string Host = PS3.Extension.ReadString(0x01C33DB0);
            int i = 0;
            if (Host == "")
            {
                i = 0;
            }
            else if (Host == PS3.Extension.ReadString(0x011008B8 + (0 * 0x1d30)))
            {
                i = 0;
            }
            else if (Host == PS3.Extension.ReadString(0x011008B8 + (1 * 0x1d30)))
            {
                i = 1;
            }
            else if (Host == PS3.Extension.ReadString(0x011008B8 + (2 * 0x1d30)))
            {
                i = 2;
            }
            else if (Host == PS3.Extension.ReadString(0x011008B8 + (3 * 0x1d30)))
            {
                i = 3;
            }
            return i;
        }

public static void SV_GameSendServerCommand(int client, string command)
            {
                RPC.Call(0x003C33A8, client, 1, command);
            }