Adresses et Offsets BO3 1.03 + mise à jour toutes versions

tonyleffe · 24 Novembre 2015

Developer_C# a dit:
black screen : 0x26EFC20 ON : 0x01 OFF : 0x00

Credit : Moi

Fonctionnel

mais moi je ne vois l'intérêt de se mettre dans le noir

deleted585952 · 24 Novembre 2015

tonyleffe a dit:
Fonctionnel mais moi je ne vois l'intérêt de se mettre dans le noir

Remonte la discution j'ai mit 2 mods non hist en plus que ta pas add

Saint Bratune · 24 Novembre 2015

GsRClans' a dit:

Essaye sa, si sa marche temps mieux

:

Code:

unsigned int function_address = 0x3CE408;


    int Call(unsigned int func_address, ...)
    {
        int length = parameters->Length;
        int index = 0;
        unsigned int num3 = 0;
        unsigned int num4 = 0;
        unsigned int num5 = 0;
        unsigned int num6 = 0;
        while (index < length)
        {
            if (dynamic_cast<int>(parameters[index]) != nullptr)
            {
                PS3::Extension::WriteInt32(0x10020000 + (num3 * 4), static_cast<int>(parameters[index]));
                num3++;
            }
            else if (dynamic_cast<unsigned int>(parameters[index]) != nullptr)
            {
                PS3::Extension::WriteUInt32(0x10020000 + (num3 * 4), static_cast<unsigned int>(parameters[index]));
                num3++;
            }
            else
            {
                unsigned int num7;
                if (dynamic_cast<std::wstring>(parameters[index]) != nullptr)
                {
                    num7 = 0x10022000 + (num4 * 0x400);
                    PS3::Extension::WriteString(num7, static_cast<std::wstring>(parameters[index]));
                    PS3::Extension::WriteUInt32(0x10020000 + (num3 * 4), num7);
                    num3++;
                    num4++;
                }
                else if (dynamic_cast<float>(parameters[index]) != nullptr)
                {
                    PS3::Extension::WriteFloat(0x10020024 + (num5 * 4), static_cast<float>(parameters[index]));
                    num5++;
                }
                else if (dynamic_cast<float[]>(parameters[index]) != nullptr)
                {

                    float *input = static_cast<float[]>(parameters[index]);
                    num7 = 0x10021000 + (num6 * 4);
                    WriteSingle(num7, input);
                    PS3::Extension::WriteUInt32(0x10020000 + (num3 * 4), num7);
                    num3++;
                    num6 += static_cast<unsigned int>(input->Length);
                }
            }
            index++;
        }
        PS3::Extension::WriteUInt32(0x1002004C, func_address);
        delay(20);
        return PS3::Extension::ReadInt32(0x10020050);
    }

    void Enable_RPC()
    {
        if (PS3::Extension::ReadByte(function_address + 0xB) == 0xD0)
        {
            PS3::SetMemory(function_address, new unsigned char[] {0x4E, 0x80, 0x00, 0x20});
            delay(20);
            unsigned char memory[136] = {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};
            PS3::SetMemory(function_address + 4, memory);
            PS3::SetMemory(0x10020000, new unsigned char[0x2854]);
            PS3::SetMemory(function_address, new unsigned char[] {0xF8, 0x21, 0xFF, 0x91});
        }
        else
        {

        }
    }

    int Init()
    {
        function_address = 0x3CE408;
        Enable_RPC();
        return 0;
    }

thx

tonyleffe · 24 Novembre 2015

Marentdu93 a dit:
Remonte la discution j'ai mit 2 mods non hist en plus que ta pas add

si j'ai testé les 2 mais non fonctionnel, color player = wallhack? et l'autre=ADUAV ?

deleted585952 · 24 Novembre 2015

Melvin SEC a dit:
On : 0xCB918 ?

Non le on jai pas alors test un NOP ou alors remplace 00 a la fin par 01 ou 02

deleted585952 · 24 Novembre 2015

tonyleffe a dit:
si j'ai testé les 2 mais non fonctionnel, color player = wallhack? et l'autre=ADUAV ?

Color players et HART si je me souviens normalement y devrait marcher

deleted585952 · 24 Novembre 2015

tonyleffe a dit:
si j'ai testé les 2 mais non fonctionnel, color player = wallhack? et l'autre=ADUAV ?

Euh non rien avoir avec uav ou wallhack cest dautre mods ^^

tonyleffe · 24 Novembre 2015

Marentdu93 a dit:
Tient FPS Enable = 0xCB918 OFF : 2C 03 00 00 // a TEST
Credits : @Marentdu93
Non - Host :
Color Player = 0x113C40 - 0x38 0xC0 0xFF 0xFF - OFF : new byte [0]

H.A.T.R = 0xC7808 - 0x60 0x00 0x00 0x00

on parle bien de ces 2 non-host?

deleted585952 · 24 Novembre 2015

tonyleffe a dit:
on parle bien de ces 2 non-host?

Yep je les est update en 1.03 il devrait marcher sinon je reverifirer demain ^^

iMoDz-Retour · 24 Novembre 2015

Advanced NoClip : Effectuée

tonyleffe · 24 Novembre 2015

Marentdu93 a dit:
Yep je les est update en 1.03 il devrait marcher sinon je reverifirer demain ^^

ok pas de soucis

deleted585952 · 24 Novembre 2015

tonyleffe a dit:
ok pas de soucis

Fais sa pour les 2 mods non host que je t'es donner au lieu du SetMemory
PS3.Extension.WriteBytes

deleted585952 · 24 Novembre 2015

iMoDz-Retour a dit:
Il me manque le G_SetModel j'arrive pas a trouver la bonne adresse

C'est pas sa :mmh:

0x38D4EC

deleted585952 · 24 Novembre 2015

Advanced No Clip :

Code:

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

        public static void AdvancedNoclip(int Client)
        {
            SetVelocity(Client, new float[] { ReturnVelocity(Client)[0], ReturnVelocity(Client)[1], 42.5f });

            if (ButtonPressed(Client, Buttonz.L3))
            {
                SetOrigin(Client, PlayerAnglesToForward(Client, 85));
            }
        }

        public static void SetVelocity(Int32 clientIndex, Single[] Velocity)
        {
            WriteSingle1(G_Client(clientIndex, 0x34), 3);
        }

        public static float[] ReturnVelocity(int Client)
        {
            return ReadSingle(G_Client(Client, Adresses.ClientVelocity), 3);
        }

PlayerAnglesToForward

Code:

     public static float[] PlayerAnglesToForward(int clientIndex, float Distance = 200f)
        {
            float[] Angles = ReadSingle(G_Client(clientIndex, 0x1B0), 3);
            float[] Position = ReadSingle(G_Client(clientIndex, 0x78), 3);
            float angle, sr, sp, sy, cr, cp, cy, PiDiv;
            PiDiv = ((float)Math.PI / 180f);
            angle = Angles[1] * PiDiv;
            sy = (float)Math.Sin(angle);
            cy = (float)Math.Cos(angle);
            angle = Angles[0] * PiDiv;
            sp = (float)Math.Sin(angle);
            cp = (float)Math.Cos(angle);
            angle = Angles[2] * PiDiv;
            sr = (float)Math.Sin(angle);
            cr = (float)Math.Cos(angle);
            float[] Forward = new float[] { (cp * cy * Distance) + Position[0], (cp * sy * Distance) + Position[1], (-sp * Distance) + Position[2] };
            return Forward;
        }

Set Origin :

Code:

 public static void SetOrigin(int Client, float[] Origin)
        {
            WriteSingle(G_Client(Client, 0x78), Origin);
        }

G_Client

Code:

    public static uint G_Client(int clientIndex, uint Mod = 0x00)
        {
            return (Adresses.G_Client + Mod) + ((uint)clientIndex * Intervalle);
        }

Rien de tres compliquer adtapter le Metter les bons offset

deleted585952 · 24 Novembre 2015

Forge Mods :

Code:

   public static UInt32
        G_Client = Adresses.G_Client,
        G_ClientSize = ,
        Client_mFlag = ,
        Client_Angles = ,
        Client_Origin = ;

        public static float[] distances = new float[18];
        public static PS3API PS3 = new PS3API();

        public static void ChangeCEX()
        {
            PS3.ChangeAPI(SelectAPI.ControlConsole);
        }

        public static void ChangeDEX()
        {
            PS3.ChangeAPI(SelectAPI.TargetManager);
        }

        public static void ForgeMode(uint Client, uint Target, uint Distance_in_Meters = 6)
        {
            float[] Angles = ReadFloatLength(Client_Angles + (Client * G_ClientSize), 2);
            float[] Origin = ReadFloatLength(Client_Origin + (Client * G_ClientSize), 3);

            float diff = Distance_in_Meters * 40;

            float num = ((float)Math.Sin((Angles[0] * Math.PI) / 180)) * diff;
            float num1 = (float)Math.Sqrt(((diff * diff) - (num * num)));
            float num2 = ((float)Math.Sin((Angles[1] * Math.PI) / 180)) * num1;
            float num3 = ((float)Math.Cos((Angles[1] * Math.PI) / 180)) * num1;
            float[] forward = new float[] { Origin[0] + num3, Origin[1] + num2, Origin[2] - num };

            Freeze(Target, true);
            WriteFloatArray(Client_Origin + (Target * G_ClientSize), forward);
        }

        public static uint FindClosestEnemy(uint Attacker)
        {
            for (uint i = 0; i < 18; i++)
            {
                if (IsClientAlive(i))
                {
                    float[] O1 = ReadFloatLength(Client_Origin + (Attacker * G_ClientSize), 3);
                    float[] O2 = ReadFloatLength(Client_Origin + (i * G_ClientSize), 3);
                    distances[i] = (float)(Math.Sqrt(((O2[0] - O1[0]) * (O2[0] - O1[0])) + ((O2[1] - O1[1]) * (O2[1] - O1[1])) + ((O2[2] - O1[2]) * (O2[2] - O1[2]))));

                }
                else
                {
                    distances[i] = float.MaxValue;
                }
            }

            float[] newDistances = new float[18];
            Array.Copy(distances, newDistances, distances.Length);

            Array.Sort(newDistances);
            for (uint i = 0; i < 18; i++)
            {
                if (distances[i] == newDistances[1])
                {
                    return i;
                }
            }
            int Failed = -1;
            return (uint)Failed;
        }

        public static void WriteFloatArray(uint Offset, float[] Array)
        {
            byte[] buffer = new byte[Array.Length * 4];
            for (int Lenght = 0; Lenght < Array.Length; Lenght++)
            {
                ReverseBytes(BitConverter.GetBytes(Array[Lenght])).CopyTo(buffer, Lenght * 4);
            }
            PS3.SetMemory(Offset, buffer);
        }

        public static float[] ReadFloatLength(uint Offset, int Length)
        {
            byte[] buffer = new byte[Length * 4];
            PS3.GetMemory(Offset, buffer);
            ReverseBytes(buffer);
            float[] Array = new float[Length];
            for (int i = 0; i < Length; i++)
            {
                Array[i] = BitConverter.ToSingle(buffer, (Length - 1 - i) * 4);
            }
            return Array;
        }

        public static void Freeze(uint Client, bool State)
        {
            if (State == true)
                PS3.Extension.WriteByte(Client_mFlag + (Client * G_ClientSize), 0x05);
            else
                PS3.Extension.WriteByte(Client_mFlag + (Client * G_ClientSize), 0x00);
        }

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

        public static bool IsClientAlive(uint Client)
        {
            byte Alive = PS3.Extension.ReadByte(Adresses.G_Entity + (Client * 0x280) + 0x1AF);
            if (Alive != 0)
                return true;
            else
                return false;

        }

iMoDz-Retour · 24 Novembre 2015

Marentdu93 a dit:

Forge Mods :

Code:

   public static UInt32
        G_Client = Adresses.G_Client,
        G_ClientSize = ,
        Client_mFlag = ,
        Client_Angles = ,
        Client_Origin = ;

        public static float[] distances = new float[18];
        public static PS3API PS3 = new PS3API();

        public static void ChangeCEX()
        {
            PS3.ChangeAPI(SelectAPI.ControlConsole);
        }

        public static void ChangeDEX()
        {
            PS3.ChangeAPI(SelectAPI.TargetManager);
        }

        public static void ForgeMode(uint Client, uint Target, uint Distance_in_Meters = 6)
        {
            float[] Angles = ReadFloatLength(Client_Angles + (Client * G_ClientSize), 2);
            float[] Origin = ReadFloatLength(Client_Origin + (Client * G_ClientSize), 3);

            float diff = Distance_in_Meters * 40;

            float num = ((float)Math.Sin((Angles[0] * Math.PI) / 180)) * diff;
            float num1 = (float)Math.Sqrt(((diff * diff) - (num * num)));
            float num2 = ((float)Math.Sin((Angles[1] * Math.PI) / 180)) * num1;
            float num3 = ((float)Math.Cos((Angles[1] * Math.PI) / 180)) * num1;
            float[] forward = new float[] { Origin[0] + num3, Origin[1] + num2, Origin[2] - num };

            Freeze(Target, true);
            WriteFloatArray(Client_Origin + (Target * G_ClientSize), forward);
        }

        public static uint FindClosestEnemy(uint Attacker)
        {
            for (uint i = 0; i < 18; i++)
            {
                if (IsClientAlive(i))
                {
                    float[] O1 = ReadFloatLength(Client_Origin + (Attacker * G_ClientSize), 3);
                    float[] O2 = ReadFloatLength(Client_Origin + (i * G_ClientSize), 3);
                    distances[i] = (float)(Math.Sqrt(((O2[0] - O1[0]) * (O2[0] - O1[0])) + ((O2[1] - O1[1]) * (O2[1] - O1[1])) + ((O2[2] - O1[2]) * (O2[2] - O1[2]))));

                }
                else
                {
                    distances[i] = float.MaxValue;
                }
            }

            float[] newDistances = new float[18];
            Array.Copy(distances, newDistances, distances.Length);

            Array.Sort(newDistances);
            for (uint i = 0; i < 18; i++)
            {
                if (distances[i] == newDistances[1])
                {
                    return i;
                }
            }
            int Failed = -1;
            return (uint)Failed;
        }

        public static void WriteFloatArray(uint Offset, float[] Array)
        {
            byte[] buffer = new byte[Array.Length * 4];
            for (int Lenght = 0; Lenght < Array.Length; Lenght++)
            {
                ReverseBytes(BitConverter.GetBytes(Array[Lenght])).CopyTo(buffer, Lenght * 4);
            }
            PS3.SetMemory(Offset, buffer);
        }

        public static float[] ReadFloatLength(uint Offset, int Length)
        {
            byte[] buffer = new byte[Length * 4];
            PS3.GetMemory(Offset, buffer);
            ReverseBytes(buffer);
            float[] Array = new float[Length];
            for (int i = 0; i < Length; i++)
            {
                Array[i] = BitConverter.ToSingle(buffer, (Length - 1 - i) * 4);
            }
            return Array;
        }

        public static void Freeze(uint Client, bool State)
        {
            if (State == true)
                PS3.Extension.WriteByte(Client_mFlag + (Client * G_ClientSize), 0x05);
            else
                PS3.Extension.WriteByte(Client_mFlag + (Client * G_ClientSize), 0x00);
        }

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

        public static bool IsClientAlive(uint Client)
        {
            byte Alive = PS3.Extension.ReadByte(Adresses.G_Entity + (Client * 0x280) + 0x1AF);
            if (Alive != 0)
                return true;
            else
                return false;

        }

Si c'est si simple fait le , mais au moins les crédit

deleted585952 · 24 Novembre 2015

Jet Pack :

Code:

  public void JetPack(int client)
        {
            float jH = PS3.Extension.ReadFloat(Adresses.G_Client + 0x8C + ((uint)client * intervalle));
            jH += 100;
            PS3.Extension.WriteFloat(Adresses.G_Client + 0x8C + ((uint)client * intervalle), jH);
        }

deleted585952 · 24 Novembre 2015

iMoDz-Retour a dit:
Si c'est si simple fait le , mais au moins les crédit

Jai pas fini sa arrive et je n'est aps le temps pour sa en ce moment

deleted585952 · 24 Novembre 2015

Aimbot

Code:

      public static uint G_Client = ;
        public static uint Client_Stance =;
        public static uint Client_Alive = ;
        public static uint Client_Team = ;
        public static uint Client_SetClientViewAngles = Adresses.SetClientViewAngles;
        public static uint Client_IsInGame = ;
        public static uint Client_Angles = ;
        public static uint Client_Origin = ;
        public static uint ClientInterval = ;

        public static float[] getPlayerPosition(int clientIndex)
        {
            return ReadSingle(Client_Origin + (intervalle* (uint)clientIndex));
        }

        public static void ChangeCEX()
        {
            PS3.ChangeAPI(SelectAPI.ControlConsole);
        }

        public static void ChangeDEX()
        {
            PS3.ChangeAPI(SelectAPI.TargetManager);
        }

        public static bool ClientIsSameTeam(int clientIndex, int otherPlayer)
        {
            return (PS3.Extension.ReadInt32(Client_Team + ((uint)clientIndex * intervalle)) == PS3.Extension.ReadInt32(Client_Team + ((uint)otherPlayer * intervalle)));
        }

        public static bool ClientIsInGame(int clientIndex)
        {
            return (PS3.Extension.ReadInt32(Client_IsInGame + ((uint)clientIndex * intervalle)) != 0);
        }

        public static bool ClientIsAlive(int clientIndex)
        {
            return (PS3.Extension.ReadInt32(Client_Alive + ((uint)clientIndex * intervalle)) == 0);
        }

        public static float[] vectoangles(float[] Angles)
        {
            float forward;
            float yaw, pitch;
            float[] angles = new float[3];
            if (Angles[1] == 0 && Angles[0] == 0)
            {
                yaw = 0;
                if (Angles[2] > 0) pitch = 90f;
                else pitch = 270f;
            }
            else
            {
                if (Angles[0] != -1) yaw = (float)(Math.Atan2((double)Angles[1], (double)Angles[0]) * 180f / Math.PI);
                else if (Angles[1] > 0) yaw = 90f;
                else yaw = 270;
                if (yaw < 0) yaw += 360f;

                forward = (float)Math.Sqrt((double)(Angles[0] * Angles[0] + Angles[1] * Angles[1]));
                pitch = (float)(Math.Atan2((double)Angles[2], (double)forward) * 180f / Math.PI);
                if (pitch < 0) pitch += 360f;
            }
            angles[0] = -pitch;
            angles[1] = yaw;
            angles[2] = 0;

            return angles;
        }

        public static float[] getVector(float[] point1, float[] point2)
        {
            return new float[] { (point2[0] - point1[0]), (point2[1] - point1[1]), (point2[2] - point1[2]) };
        }

        public static float Distance3D(float[] point1, float[] point2)
        {
            float deltax = point2[0] - point1[0];
            float deltay = point2[1] - point1[1];
            float deltaz = point2[2] - point1[2];
            return Convert.ToSingle(Math.Sqrt((deltax * deltax) + (deltay * deltay) + (deltaz * deltaz)));
        }

        public static float Distance2D(float[] point1, float[] point2)
        {
            float deltax = point2[0] - point1[0];
            float deltaz = point2[1] - point1[1];
            return Convert.ToSingle(Math.Sqrt((deltax * deltax) + (deltaz * deltaz)));
        }

        public static void vec_scale(float[] vec, float scale, out float[] Forward)
        {
            Forward = new float[] { vec[0] * scale, vec[1] * scale, vec[2] * scale };
        }

        public static int GetNearestPlayer(Int32 clientIndex, Boolean EnemyOnly = false)
        {
            int nearestClient = 0;
            float nearestDistance = 99999999;
            for (int i = 0; i < 12; i++)
            {
                if (i != clientIndex)
                {
                    if ((ClientIsInGame(i)) && ClientIsAlive(i))
                    {
                        if (PS3.Extension.ReadInt32(Client_Team + ((uint)clientIndex * intervalle)) != 0 && EnemyOnly)
                        {
                            if (!ClientIsSameTeam(clientIndex, i))
                            {
                                float Distance = Distance3D(getPlayerPosition(clientIndex), getPlayerPosition(i));
                                if (Distance < nearestDistance)
                                {
                                    nearestDistance = Distance;
                                    nearestClient = i;
                                }
                            }
                        }
                        else
                        {
                            float Distance = Distance3D(getPlayerPosition(clientIndex), getPlayerPosition(i));
                            if (Distance < nearestDistance)
                            {
                                nearestDistance = Distance;
                                nearestClient = i;
                            }
                        }
                    }
                }
            }
            return nearestClient;
        }

        public static bool[] AimbotStatus = new bool[12];
        public static Thread[] AimbotThread = new Thread[12];

        private static float CheckStance(int clientIndex)
        {
            Int32 CurrentStance = PS3.Extension.ReadByte(Client_Stance + ((uint)clientIndex * intervalle));
            if (CurrentStance == 0x08 || CurrentStance == 0x0A || CurrentStance == 0x48 || CurrentStance == 0x4A)
            { return 44f; }
            if (CurrentStance == 0x04 || CurrentStance == 0x06 || CurrentStance == 0x44 || CurrentStance == 0x46)
            { return 14f; }
            return 0f;
        }
        private static float CheckStanceAttacker(int clientIndex)
        {
            Int32 CurrentStance = PS3.Extension.ReadByte(Client_Stance + ((uint)clientIndex * intervalle));
            if (CurrentStance == 0x08 || CurrentStance == 0x0A || CurrentStance == 0x48 || CurrentStance == 0x4A)
            { return 46f; }
            if (CurrentStance == 0x04 || CurrentStance == 0x06 || CurrentStance == 0x44 || CurrentStance == 0x46)
            { return 18f; }
            return 0f;
        }

        public static void InitializeAimbot(int clientIndex)
        {
            PS3.ConnectTarget();
            while (AimbotStatus[clientIndex])
            {
                int nearestPlayer = GetNearestPlayer(clientIndex);
                if (nearestPlayer != clientIndex)
                {
                    SetClientViewAngles(clientIndex, nearestPlayer);
                }
            }
        }

        public static float[] PlayerAnglesToForward(int clientIndex, float Distance = 200f)
        {
            float[] Angles = ReadSingle(Client_Angles + ((uint)clientIndex + intervalle));
            float[] Position = ReadSingle(Client_Origin + ((uint)clientIndex * intervalle));
            float angle, sr, sp, sy, cr, cp, cy, PiDiv;
            PiDiv = ((float)Math.PI / 180f);
            angle = Angles[1] * PiDiv;
            sy = (float)Math.Sin(angle);
            cy = (float)Math.Cos(angle);
            angle = Angles[0] * PiDiv;
            sp = (float)Math.Sin(angle);
            cp = (float)Math.Cos(angle);
            angle = Angles[2] * PiDiv;
            sr = (float)Math.Sin(angle);
            cr = (float)Math.Cos(angle);
            float[] Forward = new float[] { (cp * cy * Distance) + Position[0], (cp * sy * Distance) + Position[1], (-sp * Distance) + Position[2] };
            return Forward;
        }

        public static float[] AnglesToForward(float[] Angles, float Distance = 200f)
        {
            float angle, sr, sp, sy, cr, cp, cy, PiDiv;
            PiDiv = ((float)Math.PI / 180f);
            angle = Angles[1] * PiDiv;
            sy = (float)Math.Sin(angle);
            cy = (float)Math.Cos(angle);
            angle = Angles[0] * PiDiv;
            sp = (float)Math.Sin(angle);
            cp = (float)Math.Cos(angle);
            angle = Angles[2] * PiDiv;
            sr = (float)Math.Sin(angle);
            cr = (float)Math.Cos(angle);
            float[] Forward = new float[] { (cp * cy * Distance), (cp * sy * Distance), (-sp * Distance) };
            return Forward;
        }

        public static void SetClientViewAngles(int clientIndex, int Victim)
        {
            float[] Vec = getVector(getPlayerPosition(clientIndex), getPlayerPosition(Victim));
            Vec[2] -= CheckStance(Victim);
            Vec[2] += CheckStanceAttacker(clientIndex);
            float[] Angles = vectoangles(Vec);
            setViewAngles((UInt32)clientIndex, Angles);
        }

        public static uint G_Entity(int Client, uint Mod = 0)
        {
            return (Adresses.G_Entity + (0x280 * (uint)Client) + (uint)Mod);
        }

        public static void setViewAngles(UInt32 clientIndex, float[] Angles)
        {
            WriteSingle(0x10040000, Angles);
            RPC.Call(Client_SetClientViewAngles, new object[] { G_Entity((int)clientIndex, 0), 0x10040000 });
        }

        public static float[] getViewAngles(int clientIndex)
        {
            return ReadSingle(Client_Angles + ((uint)clientIndex + intervalle));
        }

        public static float[] ReadSingle(uint Address)
        {
            float[] FloatArr = new float[3];
            FloatArr[0] = PS3.Extension.ReadFloat(Address);
            FloatArr[1] = PS3.Extension.ReadFloat(Address + 0x04);
            FloatArr[2] = PS3.Extension.ReadFloat(Address + 0x08);
            return FloatArr;
        }

        public static void WriteSingle(uint Address, float[] FloatArr)
        {
            PS3.Extension.WriteFloat(Address, FloatArr[0]);
            PS3.Extension.WriteFloat(Address + 0x04, FloatArr[1]);
            PS3.Extension.WriteFloat(Address + 0x08, FloatArr[2]);
        }

deleted585952 · 24 Novembre 2015

Credits:
- GsrClan & AlexS for some functions.
- LBK.
- RGaming.
- Shark.
- SC58.
- oStankyModz.
- Sticky.
- and the others.

Adresses et Offsets BO3 1.03 + mise à jour toutes versions

tonyleffe

Membre

deleted585952

Saint Bratune

Banni

tonyleffe

Membre

deleted585952

deleted585952

deleted585952

tonyleffe

Membre

deleted585952

iMoDz-Retour

tonyleffe

Membre

deleted585952

deleted585952

deleted585952

deleted585952

iMoDz-Retour

deleted585952

deleted585952

deleted585952

deleted585952