1. Ce site utilise des cookies. En continuant à utiliser ce site, vous acceptez l'utilisation des cookies. En savoir plus.

[1.20] RPC Base's [BLES, BLUS]

Discussion dans 'Grand Theft Auto V' créé par iHαx † Mαssiliα, 4 Janvier 2015.

Statut de la discussion:
N'est pas ouverte pour d'autres réponses.
  1. iHαx † Mαssiliα

    iHαx † Mαssiliα Membre

    Hors Ligne
    Salut a tous! Aujourd'hui je vous release les Bases du RPC en 1.20 pour BLES et BLUS! Fonctionne a 100% sur mon tool!

    using System;
    using System.Threading;

    public static class RPC
    {

    private static uint SFA1 = 0x01B73580;
    private static uint EFA1 = 0x01B73608;
    private static uint SFA2 = 0x01B73680;
    private static uint EFA2 = 0x01B73708;
    private static uint SFA3 = 0x01B73780;
    private static uint EFA3 = 0x01B73808;
    private static uint BFA1 = 0x185B4;
    private static uint BAB1 = 0x185C0;
    private static uint BFA2 = 0x1AC3C;
    private static uint BAB2 = 0x1AC08;
    private static uint BFA3 = 0xB490C;
    private static uint BAB3 = 0xB4864;

    public static uint CBAB(uint F, uint T)
    {
    if (F > T)
    return 0x4C000000 - (F - T);
    else if (F < T)
    return T - F + 0x48000000;
    else
    return 0x48000000;
    }

    public static void Enable()
    {
    byte[] mem = new byte[] { 0xF8, 0x21, 0xFF, 0x91, 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 };
    PS3.SetMemory(SFA1, mem);
    PS3.SetMemory(SFA2, mem);
    PS3.SetMemory(SFA3, mem);
    PS3.Extension.WriteUInt32(EFA1, CBAB(EFA1, BAB1));
    PS3.Extension.WriteUInt32(BFA1, CBAB(BFA1, SFA1));
    PS3.Extension.WriteUInt32(EFA2, CBAB(EFA2, BAB2));
    PS3.Extension.WriteUInt32(BFA2, CBAB(BFA2, SFA2));
    PS3.Extension.WriteUInt32(EFA3, CBAB(EFA3, BAB3));
    PS3.Extension.WriteUInt32(BFA3, CBAB(BFA3, SFA3));
    }

    public static int Call(uint func_address, params object[] parameters)
    {
    int length = parameters.Length;
    int index = 0;
    uint num3 = 0;
    uint num4 = 0;
    uint num5 = 0;
    uint num6 = 0;
    while (index < length)
    {
    if (parameters[index] is int)
    {
    PS3.Extension.WriteInt32(0x10020000 + (num3 * 4), (int)parameters[index]);
    num3++;
    }
    else if (parameters[index] is uint)
    {
    PS3.Extension.WriteUInt32(0x10020000 + (num3 * 4), (uint)parameters[index]);
    num3++;
    }
    else
    {
    uint num7;
    if (parameters[index] is string)
    {
    num7 = 0x10022000 + (num4 * 0x400);
    PS3.Extension.WriteString(num7, Convert.ToString(parameters[index]));
    PS3.Extension.WriteUInt32(0x10020000 + (num3 * 4), num7);
    num3++;
    num4++;
    }
    else if (parameters[index] is float)
    {
    WriteSingle(0x10020024 + (num5 * 4), (float)parameters[index]);
    num5++;
    }
    else if (parameters[index] is float[])
    {
    float[] input = (float[])parameters[index];
    num7 = 0x10021000 + (num6 * 4);
    WriteSingle(num7, input);
    PS3.Extension.WriteUInt32(0x10020000 + (num3 * 4), num7);
    num3++;
    num6 += (uint)input.Length;
    }
    }
    index++;
    }
    PS3.Extension.WriteUInt32(0x1002004C, func_address);
    Thread.Sleep(20);
    return PS3.Extension.ReadInt32(0x10020050);
    }

    private static void WriteSingle(uint address, float input)
    {
    byte[] Bytes = new byte[4];
    BitConverter.GetBytes(input).CopyTo((Array)Bytes, 0);
    Array.Reverse((Array)Bytes, 0, 4);
    PS3.SetMemory(address, Bytes);
    }

    private static void WriteSingle(uint address, float[] input)
    {
    int length = input.Length;
    byte[] Bytes = new byte[length * 4];
    for (int index = 0; index < length; ++index)
    ReverseBytes(BitConverter.GetBytes(input[index])).CopyTo((Array)Bytes, index * 4);
    PS3.SetMemory(address, Bytes);
    }

    private static byte[] ReverseBytes(byte[] toReverse)
    {
    Array.Reverse((Array)toReverse);
    return toReverse;
    }
    }

    using System;
    using System.Threading;

    public static class RPC
    {

    private static uint SFA1 = 0x01b8E980;
    private static uint EFA1 = 0x01B8EA08;
    private static uint SFA2 = 0x01B8EA80;
    private static uint EFA2 = 0x01B8EB08;
    private static uint SFA3 = 0x01B8EB80;
    private static uint EFA3 = 0x01B8EC08;
    private static uint BFA1 = 0x18864;
    private static uint BAB1 = 0x18870;
    private static uint BFA2 = 0x1AEEC;
    private static uint BAB2 = 0x1AEB8;
    private static uint BFA3 = 0xB589C;
    private static uint BAB3 = 0xB57F4;

    public static uint CBAB(uint F, uint T)
    {
    if (F > T)
    return 0x4C000000 - (F - T);
    else if (F < T)
    return T - F + 0x48000000;
    else
    return 0x48000000;
    }

    public static void Enable()
    {
    byte[] mem = new byte[] { 0xF8, 0x21, 0xFF, 0x91, 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 };
    PS3.SetMemory(SFA1, mem);
    PS3.SetMemory(SFA2, mem);
    PS3.SetMemory(SFA3, mem);
    PS3.Extension.WriteUInt32(EFA1, CBAB(EFA1, BAB1));
    PS3.Extension.WriteUInt32(BFA1, CBAB(BFA1, SFA1));
    PS3.Extension.WriteUInt32(EFA2, CBAB(EFA2, BAB2));
    PS3.Extension.WriteUInt32(BFA2, CBAB(BFA2, SFA2));
    PS3.Extension.WriteUInt32(EFA3, CBAB(EFA3, BAB3));
    PS3.Extension.WriteUInt32(BFA3, CBAB(BFA3, SFA3));
    }

    public static int Call(uint func_address, params object[] parameters)
    {
    int length = parameters.Length;
    int index = 0;
    uint num3 = 0;
    uint num4 = 0;
    uint num5 = 0;
    uint num6 = 0;
    while (index < length)
    {
    if (parameters[index] is int)
    {
    PS3.Extension.WriteInt32(0x10020000 + (num3 * 4), (int)parameters[index]);
    num3++;
    }
    else if (parameters[index] is uint)
    {
    PS3.Extension.WriteUInt32(0x10020000 + (num3 * 4), (uint)parameters[index]);
    num3++;
    }
    else
    {
    uint num7;
    if (parameters[index] is string)
    {
    num7 = 0x10022000 + (num4 * 0x400);
    PS3.Extension.WriteString(num7, Convert.ToString(parameters[index]));
    PS3.Extension.WriteUInt32(0x10020000 + (num3 * 4), num7);
    num3++;
    num4++;
    }
    else if (parameters[index] is float)
    {
    WriteSingle(0x10020024 + (num5 * 4), (float)parameters[index]);
    num5++;
    }
    else if (parameters[index] is float[])
    {
    float[] input = (float[])parameters[index];
    num7 = 0x10021000 + (num6 * 4);
    WriteSingle(num7, input);
    PS3.Extension.WriteUInt32(0x10020000 + (num3 * 4), num7);
    num3++;
    num6 += (uint)input.Length;
    }
    }
    index++;
    }
    PS3.Extension.WriteUInt32(0x1002004C, func_address);
    Thread.Sleep(20);
    return PS3.Extension.ReadInt32(0x10020050);
    }

    private static void WriteSingle(uint address, float input)
    {
    byte[] Bytes = new byte[4];
    BitConverter.GetBytes(input).CopyTo((Array)Bytes, 0);
    Array.Reverse((Array)Bytes, 0, 4);
    PS3.SetMemory(address, Bytes);
    }

    private static void WriteSingle(uint address, float[] input)
    {
    int length = input.Length;
    byte[] Bytes = new byte[length * 4];
    for (int index = 0; index < length; ++index)
    ReverseBytes(BitConverter.GetBytes(input[index])).CopyTo((Array)Bytes, index * 4);
    PS3.SetMemory(address, Bytes);
    }

    private static byte[] ReverseBytes(byte[] toReverse)
    {
    Array.Reverse((Array)toReverse);
    return toReverse;
    }
    }

    Bon Modding a vous et Bonne année 2015 :ignoel:
     
    2 personnes aiment ça.
  2. Anthony.

    Anthony. Membre

    Hors Ligne
  3. JOKEER

    JOKEER Premium Membre

    Hors Ligne
  4. antonorm

    antonorm Membre

    Hors Ligne
  5. zSw4LiiT

    zSw4LiiT Membre

    Hors Ligne
Statut de la discussion:
N'est pas ouverte pour d'autres réponses.

Partager cette page