(adsbygoogle = window.adsbygoogle || []).push({}); OK, so I have the correct code for everything, I'm not a noob at coding. But RPC simply doesn't work for me, I enable it and I can't use the codes that require it, like Sv_GameSendServerCommand, Dvars, or anything like that. I tried a RPC library and it froze everytime I tried to activate something, so maybe I'm doing something wrong... Maybe if someone could explain to me exactly how RPC works and wtf is PPC, cause I saw in a few threads that you need to do something with it... Thanks in advance to anyone that answers it

1st off its not "Real Procedure Call" It's Remote Procedure Call, 2nd please state what are you exactly trying to call in RPC?

OK, Cmd_ExecuteSingleCommand and CBuf_AddText, or any HUD element, but none of them work. Let's say that I already got the complete RPC class, now I want to Enable it, but just writing the Enable(); from the RPC class is not working, I can't use those codes and also I can't get memory anymore until I restart my PS3, like get players name, for example. I looked for any tip in some tools sources and couldn't find anything that could help me, cause their class are exactly like mine but it works. So I think that maybe the problem isn't in my coding, but in my PS3, can it be? Thanks for replying tho

Commands I'm trying to call via RPC:

    

       public static void Cmd_ExecuteSingleCommand(int client, string command)

       {

           RPC.Call(0x1db240, client, (command), 0, 0, 0);

       }

       public static void CBuf_AddText(int client, string command)

       {

           RPC.Call(0x1db240, client, (command), 0, 0, 0);

       }

       public static void SV_GameSendServerCommand(int client, string command)

       {

           RPC.Call(0x228FA8 client, (command)), 0, 0);

           Thread.Sleep(20);

       }

Shark's RPC:

    public static class Shark_RPC

                {

                    public static void WriteSingle(UInt32 address, float[] input)

                    {

                        Int32 length = input.Length;

                        Byte[] array = new Byte[length * 4];

                        for (Int32 i = 0; i < length; i++)

                        {

                            Lib.ReverseBytes(BitConverter.GetBytes(input[i])).CopyTo(array, (Int32)(i * 4));

                        }

                        Lib.SetMemory(address, array);

                    }



                    private static UInt32 RPCFogAddr;

                    public static Int32 Init()

                    {

                        RPCFogAddr = 0x3BC990;

                        Enable();

                        return 0;

                    }

                    public static void Enable()

                    {

                        Lib.SetMemory(RPCFogAddr, new Byte[] { 0x4E, 0x80, 0x00, 0x20 });

                        Thread.Sleep(20);

                        Byte[] memory = new Byte[]

                    { 0x7C, 0x08, 0x02, 0xA6, 0xF8, 0x01, 0x00, 0x80, 0x3C, 0x60, 0x10, 0x02, 0x81, 0x83, 0x00, 0x4C,

            0x2C, 0x0C, 0x00, 0x00, 0x41, 0x82, 0x00, 0x64, 0x80, 0x83, 0x00, 0x04, 0x80, 0xA3, 0x00, 0x08,

            0x80, 0xC3, 0x00, 0x0C, 0x80, 0xE3, 0x00, 0x10, 0x81, 0x03, 0x00, 0x14, 0x81, 0x23, 0x00, 0x18,

            0x81, 0x43, 0x00, 0x1C, 0x81, 0x63, 0x00, 0x20, 0xC0, 0x23, 0x00, 0x24, 0xc0, 0x43, 0x00, 0x28,

            0xC0, 0x63, 0x00, 0x2C, 0xC0, 0x83, 0x00, 0x30, 0xC0, 0xA3, 0x00, 0x34, 0xc0, 0xC3, 0x00, 0x38,

            0xC0, 0xE3, 0x00, 0x3C, 0xC1, 0x03, 0x00, 0x40, 0xC1, 0x23, 0x00, 0x48, 0x80, 0x63, 0x00, 0x00,

            0x7D, 0x89, 0x03, 0xA6, 0x4E, 0x80, 0x04, 0x21, 0x3C, 0x80, 0x10, 0x02, 0x38, 0xA0, 0x00, 0x00,

            0x90, 0xA4, 0x00, 0x4C, 0x90, 0x64, 0x00, 0x50, 0xE8, 0x01, 0x00, 0x80, 0x7C, 0x08, 0x03, 0xA6,

            0x38, 0x21, 0x00, 0x70, 0x4E, 0x80, 0x00, 0x20 };

                        Lib.SetMemory(RPCFogAddr + 4, memory);

                        Lib.SetMemory(0x10020000, new Byte[0x2854]);

                        Lib.SetMemory(RPCFogAddr, new Byte[] { 0xF8, 0x21, 0xFF, 0x91 });

                    }



                    public static Int32 CallFunc(UInt32 func_address, params object[] parameters)

                    {

                        Int32 length = parameters.Length;

                        Int32 index = 0;

                        UInt32 num3 = 0;

                        UInt32 num4 = 0;

                        UInt32 num5 = 0;

                        UInt32 num6 = 0;

                        while (index < length)

                        {

                            if (parameters[index] is Int32)

                            {

                                Lib.WriteInt32(0x10020000 + (num3 * 4), (Int32)parameters[index]);

                                num3++;

                            }

                            else if (parameters[index] is UInt32)

                            {

                                Lib.WriteUInt32(0x10020000 + (num3 * 4), (UInt32)parameters[index]);

                                num3++;

                            }

                            else

                            {

                                UInt32 num7;

                                if (parameters[index] is string)

                                {

                                    num7 = 0x10022000 + (num4 * 0x400);

                                    Lib.WriteString(num7, Convert.ToString(parameters[index]));

                                    Lib.WriteUInt32(0x10020000 + (num3 * 4), num7);

                                    num3++;

                                    num4++;

                                }

                                else if (parameters[index] is float)

                                {

                                    Lib.WriteFloat(0x10020024 + (num5 * 4), (float)parameters[index]);

                                    num5++;

                                }

                                else if (parameters[index] is float[])

                                {

                                    float[] input = (float[])parameters[index];

                                    num7 = 0x10021000 + (num6 * 4);

                                    Lib.WriteSingle(num7, input);

                                    Lib.WriteUInt32(0x10020000 + (num3 * 4), num7);

                                    num3++;

                                    num6 += (UInt32)input.Length;

                                }

                            }

                            index++;

                        }

                        Lib.WriteUInt32(0x1002004C, func_address);

                        Thread.Sleep(20);

                        return Lib.ReadInt32(0x10020050);

                    }

                }

Vezah|Nico's RPC:

    public static UInt32 func_address = 0x0277208; //FPS Address 1.24

                /*

                 * MW3 FPS RPC by VezahHFH! 

                 * This function get written at the FPS Offset!

                 * 

                     lis r28, 0x1005

                     lwz r12, 0x48(r2

                     cmpwi r12, 0

                     beq loc_277290

                     lwz r3, 0x00(r2

                     lwz r4, 0x04(r2

                     lwz r5, 0x08(r2

                     lwz r6, 0x0C(r2

                     lwz r7, 0x10(r2

                     lwz r8, 0x14(r2

                     lwz r9, 0x18(r2

                     lwz r10, 0x1C(r2

                     lwz r11, 0x20(r2

                     lfs f1, 0x24(r2

                     lfs f2, 0x28(r2

                     lfs f3, 0x2C(r2

                     lfs f4, 0x30(r2

                     lfs f5, 0x34(r2

                     lfs f6, 0x38(r2

                     lfs f7, 0x3C(r2

                     lfs f8, 0x40(r2

                     lfs f9, 0x44(r2

                     mtctr r12

                     bctrl

                     li r4, 0

                     stw r4, 0x48(r2

                     stw r3, 0x4C(r2

                     stfs f1, 0x50(r2

                     b loc_277290

                 */

                public static UInt32 GetFuncReturn()

                {

                    Byte[] ret = new Byte[4];

                    Lib.GetMemoryR(0x114AE64, ref ret);

                    Array.Reverse(ret);

                    return BitConverter.ToUInt32(ret, 0);

                }

                public static void Enable()

                {

                    if (Lib.ReadByte(0x27720C) == 0x80)

                    {

                        Byte[] WritePPC = new Byte[] {0x3F,0x80,0x10,0x05,0x81,0x9C,0x00,0x48,0x2C,0x0C,0x00,0x00,0x41,0x82,0x00,0x78,

                                        0x80,0x7C,0x00,0x00,0x80,0x9C,0x00,0x04,0x80,0xBC,0x00,0x08,0x80,0xDC,0x00,0x0C,

                                        0x80,0xFC,0x00,0x10,0x81,0x1C,0x00,0x14,0x81,0x3C,0x00,0x18,0x81,0x5C,0x00,0x1C,

                                        0x81,0x7C,0x00,0x20,0xC0,0x3C,0x00,0x24,0xC0,0x5C,0x00,0x28,0xC0,0x7C,0x00,0x2C,

                                        0xC0,0x9C,0x00,0x30,0xC0,0xBC,0x00,0x34,0xC0,0xDC,0x00,0x38,0xC0,0xFC,0x00,0x3C,

                                        0xC1,0x1C,0x00,0x40,0xC1,0x3C,0x00,0x44,0x7D,0x89,0x03,0xA6,0x4E,0x80,0x04,0x21,

                                        0x38,0x80,0x00,0x00,0x90,0x9C,0x00,0x48,0x90,0x7C,0x00,0x4C,0xD0,0x3C,0x00,0x50,

                                        0x48,0x00,0x00,0x14};

                        Lib.SetMemory(func_address, new Byte[] { 0x41 });

                        Lib.SetMemory(func_address + 4, WritePPC);

                        Lib.SetMemory(func_address, new Byte[] { 0x40 });

                        Thread.Sleep(10);

                        RPC.DestroyAll();

                    }

                    else

                    {

                    }

                }

                public static Int32 Call(UInt32 address, params Object[] parameters)

                {

                    Int32 length = parameters.Length;

                    Int32 index = 0;

                    UInt32 count = 0;

                    UInt32 Strings = 0;

                    UInt32 Single = 0;

                    UInt32 Array = 0;

                    while (index < length)

                    {

                        if (parameters[index] is Int32)

                        {

                            Lib.WriteInt32(0x10050000 + (count * 4), (Int32)parameters[index]);

                            count++;

                        }

                        else if (parameters[index] is UInt32)

                        {

                            Lib.WriteUInt32(0x10050000 + (count * 4), (UInt32)parameters[index]);

                            count++;

                        }

                        else if (parameters[index] is Int16)

                        {

                            Lib.WriteInt16(0x10050000 + (count * 4), (Int16)parameters[index]);

                            count++;

                        }

                        else if (parameters[index] is UInt16)

                        {

                            Lib.WriteUInt16(0x10050000 + (count * 4), (UInt16)parameters[index]);

                            count++;

                        }

                        else if (parameters[index] is Byte)

                        {

                            Lib.WriteByte(0x10050000 + (count * 4), (Byte)parameters[index]);

                            count++;

                        } //Should work now  let me try 

                        else

                        {

                            UInt32 pointer;

                            if (parameters[index] is String)

                            {

                                pointer = 0x10052000 + (Strings * 0x400);

                                Lib.WriteString(pointer, Convert.ToString(parameters[index]));

                                Lib.WriteUInt32(0x10050000 + (count * 4), pointer);

                                count++;

                                Strings++;

                            }

                            else if (parameters[index] is Single)

                            {

                                Lib.WriteSingle(0x10050024 + (Single * 4), (Single)parameters[index]);

                                Single++;

                            }

                            else if (parameters[index] is Single[])

                            {

                                Single[] Args = (Single[])parameters[index];

                                pointer = 0x10051000 + Array * 4;

                                Lib.WriteSingle(pointer, Args);

                                Lib.WriteUInt32(0x10050000 + count * 4, pointer);

                                count++;

                                Array += (UInt32)Args.Length;

                            }



                        }

                        index++;

                    }

                    Lib.WriteUInt32(0x10050048, address);

                    Thread.Sleep(20);

                    return Lib.ReadInt32(0x1005004c);

                }

                public static void DestroyAll()

                {

                    Byte[] clear = new Byte[0xB4 * 1024];

                    Lib.SetMemory(0xF0E10C, clear);

                }

                private static Byte[] ReadBytes(UInt32 address, Int32 length)

                {

                    return GetMemory(address, length);

                }

                public static Single[] ReadSingle(UInt32 address, Int32 length)

                {

                    Byte[] mem = ReadBytes(address, length * 4);

                    Array.Reverse(mem);

                    float[] numArray = new float[length];

                    for (Int32 index = 0; index < length; ++index)

                        numArray[index] = BitConverter.ToSingle(mem, (length - 1 - index) * 4);

                    return numArray;

                }

> Which is the best RPC to use? <
> What is PPC? <
> What do I have to write in my "Enable" code? in the RPC class? <
> If you have a good RPC class to use it for CEX/DEX it would be much appreciated! <

Thanks.

Well I think Vezah's RPC is the best to use. You can look at my open source from my latest tool to learn and earn some handy tips. It's dex only tho.



Found here: You must login or register to view this content.

Add my skype jay_oreilly

Well I think Vezah's RPC is the best to use. You can look at my open source from my latest tool to learn and earn some handy tips. It's dex only tho.



Found here: You must login or register to view this content.

Add my skype jay_oreilly

OK, kiwi, thanks a lot for your help. Gonna download your source and look for something that can solve my problem, and if it don't I'll contact you in Skype