using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using PS3Lib;



namespace Ghosts_1._10_Aimbot

{

    class Aimbot

    {

        public static PS3API PS3 = new PS3API();

        public class Offsets

        {

            public static uint

                g_client = 0x00F44480,

                clientSize = 0x3700,

                g_entity = 0x00E04480,

                entitySize = 0x280,

                setClientViewAngles = 0x0022F8C0;

        }

        public static float[] ReadSingle(uint address, int length)

        {

            byte[] memory = PS3.Extension.ReadBytes(address, length * 4);

            ReverseBytes(memory);

            float[] numArray = new float[length];

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

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

            return numArray;

        }

        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++)

            {

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

            }

            PS3.SetMemory(address, array);

        }



        public static byte[] ReverseBytes(Byte[] toReverse)

        {

            Array.Reverse(toReverse);

            return toReverse;

        }

        public static uint G_Client(int client)

        {

            return Offsets.g_client + (Offsets.clientSize * (uint)client);

        }

        public static uint G_Entity(int client)

        {

            return Offsets.g_entity + (Offsets.entitySize * (uint)client);

        }

        public static float[] getOrigin(int client)

        {

            return ReadSingle(G_Client(client) + 0x1C, 3);

        }

        public static float[] vectoangles(float[] Angles)

        {

            float num2;

            float num3;

            float[] numArray = new float[3];

            if ((Angles[1] == 0f) && (Angles[0] == 0f))

            {

                num2 = 0f;

                if (Angles[2] > 0f)

                {

                    num3 = 90f;

                }

                else

                {

                    num3 = 270f;

                }

            }

            else

            {

                if (Angles[0] != -1f)

                {

                    num2 = (float)((Math.Atan2((double)Angles[1], (double)Angles[0]) * 180.0) / 3.1415926535897931);

                }

                else if (Angles[1] > 0f)

                {

                    num2 = 90f;

                }

                else

                {

                    num2 = 270f;

                }

                if (num2 < 0f)

                {

                    num2 += 360f;

                }

                float num = (float)Math.Sqrt((double)((Angles[0] * Angles[0]) + (Angles[1] * Angles[1])));

                num3 = (float)((Math.Atan2((double)Angles[2], (double)num) * 180.0) / 3.1415926535897931);

                if (num3 < 0f)

                {

                    num3 += 360f;

                }

            }

            numArray[0] = -num3;

            numArray[1] = num2;

            return numArray;

        }

        public static float[] getVector(int shooter, int victim)

        {

            float[] numArray = getOrigin(shooter);

            float[] numArray2 = getOrigin(victim);

            return new float[] { (numArray2[0] - numArray[0]), (numArray2[1] - numArray[1]), (numArray2[2] - numArray[2]) };

        }

        public static int nearestPlayer(int shooter)

        {

            int victim = -1;

            float closest = float.MaxValue;

            for (int i = 0; i < 12; i++)

            {

                float XYZ = getOrigin(shooter)[0] - getOrigin(i)[0];

                float distance = (float)Math.Sqrt(XYZ * XYZ);

                if ((i != shooter))

                {

                    if (distance < closest)

                    {

                        victim = i;

                        closest = distance;

                    }

                }

            }

            return victim;

        }

        public static void setClientViewAngles(int client)

        {

            int victim = nearestPlayer(client);

            float[] angles = vectoangles(getVector(client, victim));

            WriteSingle(0x10004000, angles);

            RPC.Call(Offsets.setClientViewAngles, new object[] { G_Entity(client), 0x10004000, angles });

        }

    }

}

    

#include "data.h"

#include "mod.h"



int closestClient(int clientIndex)

{

   Mod client(clientIndex);

   int cl;

   float flt = 3.4 * (10^3;//149.6

   for(int i = 0; i < (strstr(Dvar_GetString("g_gametype"),"ffa") ? 0x7 : 0xC)/*Declare Dvar_GetString yourself*/; i++)

   {

     Mod lol(i);

     if(!lol.Alive() || i == hostIndex || data().ReadInt32(lol.playerState() + 0x28F0) == data().ReadInt32(client.playerState() + 0x28F0) || i == clientIndex) continue;

     Mod clients(i);

     if(sqrt((client.bit.origin[0] - clients.bit.origin[0]) * (client.bit.origin[0] - client.bit.origin[0])) < flt)

       cl = i;

   }

   return cl;

}



void aimAtCC(int clientIndex)

{

   Mod client(clientIndex);

   Mod inf(closestClient(clientIndex));

   data().Origin2Angles(inf.bit.origin, client.bit.angle);

   client.setAngles(client.bit.angle);

}