BO2 Aimbot Source 1.18 (C#)

class Offsets
    {
        public static uint

        //G_Client
        G_Client = 0x1780F28,
        G_ClientSize = 0x5808,
        ClientOrigin = 0x28,
        ClientAngles = 0x56BC,
        ClientTeam = 0x5504,
        ClientIsAlive = 0x55D0,
        ClientStance = 0xFC,

        //Entity
        G_Entity = 0x16B9F20,
        G_EntitySize = 0x31C,
        SetClientViewAngles = 0x1E1D90;


        public class Funcs
        {
            public static float[] getPlayerPosition(int clientIndex)
            {
                float[] Position = Lib.ReadSingle(Offsets.Funcs.G_Client(clientIndex, Offsets.ClientOrigin), 3);
                return Position;
            }
            public static uint G_Client(int clientIndex, uint Mod = 0x00)
            {
                return (Offsets.G_Client + (UInt32)Mod) + ((uint)clientIndex * 0x5808);
            }
            public static uint G_Entity(int entityIndex, uint Mod = 0x00)
            {
                return (Offsets.G_Entity + (UInt32)Mod) + ((uint)entityIndex * 0x31C);
            }
        }
     }

public static bool ClientIsSameTeam(int clientIndex, int otherPlayer)
        {
            return (Lib.ReadInt32(Offsets.Funcs.G_Client(clientIndex, Offsets.ClientTeam)) == Lib.ReadInt32(Offsets.Funcs.G_Client(otherPlayer, Offsets.ClientTeam)));
        }
        public static bool ClientIsInGame(int clientIndex)
        {
            return (Lib.ReadInt32(Offsets.Funcs.G_Client(clientIndex, 0x00)) != 0);
        }
        public static bool ClientIsAlive(int clientIndex)
        {
            return (Lib.ReadInt32(Offsets.Funcs.G_Client(clientIndex, Offsets.ClientIsAlive)) == 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 int GetNearestPlayer(int clientIndex)
        {
            int nearestClient = 0;
            float nearestDistance = 99999999;
            for (int i = 0; i < MenuBase.MaxClients; i++)
            {
                if (i != clientIndex)
                {
                    if ((ClientIsInGame(i)) && ClientIsAlive(i))
                    {
                        if (Lib.ReadInt32(Offsets.Funcs.G_Client(clientIndex, Offsets.ClientTeam)) != 0)
                        {
                            if (!ClientIsSameTeam(clientIndex, i))
                            {
                                float Distance = Distance3D(Offsets.Funcs.getPlayerPosition(clientIndex), Offsets.Funcs.getPlayerPosition(i));
                                if (Distance < nearestDistance)
                                {
                                    nearestDistance = Distance;
                                    nearestClient = i;
                                }
                            }
                        }
                        else
                        {
                            float Distance = Distance3D(Offsets.Funcs.getPlayerPosition(clientIndex), Offsets.Funcs.getPlayerPosition(i));
                            if (Distance < nearestDistance)
                            {
                                nearestDistance = Distance;
                                nearestClient = i;
                            }
                        }
                    }
                }
            }
            return nearestClient;
        }

        private static float CheckStance(int clientIndex)
        {
            Int32 CurrentStance = Lib.ReadByte(Offsets.Funcs.G_Client(clientIndex, Offsets.ClientStance + 0x03));
            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 = Lib.ReadByte(Offsets.Funcs.G_Client(clientIndex, Offsets.ClientStance + 0x03));
            if (CurrentStance == 0x08 || CurrentStance == 0x0A || CurrentStance == 0x48 || CurrentStance == 0x4A)
            { return 46f; }
            if (CurrentStance == 0x04 || CurrentStance == 0x06 || CurrentStance == 0x44 || CurrentStance == 0x46)
            { return 18f; }
            return 0f;
        }

        private static void SetClientViewAngles(int clientIndex, int Victim)
        {
            float[] Vec = getVector(Offsets.Funcs.getPlayerPosition(clientIndex), Offsets.Funcs.getPlayerPosition(Victim));
            Vec[2] -= CheckStance(Victim);
            Vec[2] += CheckStanceAttacker(clientIndex);
            float[] Angles = vectoangles(Vec);
            setViewAngles((uint)clientIndex, Angles);
        }
        public static void setViewAngles(uint clientIndex, float[] Angles)
        {
            Lib.WriteSingle(0x10040000, Angles);
            RPC.Call(Offsets.SetClientViewAngles, Offsets.Funcs.G_Entity((int)clientIndex), 0x10040000);
        }


//HOW TO USE:

while (true)
{
    SetClientViewAngles(0, GetNearestPlayer(0)) //This will set aimbot to client 0
}


//CREDITS TO SHARK
//http://www.nextgenupdate.com/forums/call-duty-black-ops-2-mods-cheats-guides/731025-fair-aimbot-c-1-18-a-4.html