[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

    Inscrit:
    19 Août 2014
    Messages:
    57
    J'aime reçus:
    17
    Points:
    2 493
    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:
    ​
     
    iHαx † Mαssiliα, 4 Janvier 2015
    #1
    2 personnes aiment ça.
  2. Anthony.

    Anthony. Membre

    Inscrit:
    5 Janvier 2015
    Messages:
    10
    J'aime reçus:
    0
    Points:
    2 271
    Merci :D
     
    Anthony., 6 Janvier 2015
    #2
  3. JOKEER

    JOKEER Premium

    Inscrit:
    7 Juillet 2014
    Messages:
    5
    J'aime reçus:
    1
    Points:
    2 273
    merci mec
     
    JOKEER, 9 Janvier 2015
    #3
  4. antonorm

    antonorm Membre

    Inscrit:
    12 Juillet 2014
    Messages:
    5
    J'aime reçus:
    0
    Points:
    2 271
    thx
     
    antonorm, 10 Janvier 2015
    #4
  5. zSw4LiiT

    zSw4LiiT Membre

    Inscrit:
    28 Septembre 2014
    Messages:
    4
    J'aime reçus:
    0
    Points:
    2 271
    merci
     
    zSw4LiiT, 17 Janvier 2015
    #5
Statut de la discussion:
N'est pas ouverte pour d'autres réponses.

Partager cette page

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