Assualt Cube Offline Aimbot

#include <windows.h>
#include <math.h>
#include "classes_ac.h"

#define PI 3.14159265f
#define RAD 57.29578f

cPlayer * local;
cPlayerTable * pPlayerTable;

float absf(float a)
{
	if(a<0){return -a;}else{return a;}
}

void aim(vec to, vec from, float &yaw, float &pitch) //0-180 pitch, 0-360 yaw
{
	pitch = atan2(to.z - from.z, to.dist(from)) * 180 / PI;
	yaw = -(float)atan2(to.x - from.x, to.y - from.y) / PI * 180 + 180;
}

int target_cross()
{
	int target;
	local = *(cPlayer**)(0x004E4DBC);
	float ty, tp, t_ret;
	float ret = 999;
	pPlayerTable = *(cPlayerTable**)(0x004E4E08);
	int playercount = *(int*)(0x004E4E10);
	for(int i = 0; i < playercount - 1; i++)
	{
		playercount = *(int*)(0x004E4E10);
			aim(pPlayerTable->player[i]->pos, local->pos, ty, tp);
			t_ret = (absf(local->pitch - tp) + absf(local->yaw - ty));
			if(t_ret < ret)
			{
				ret = t_ret; //3
				target = i;
			}
	}
	return target;
}

void aimbot()
{
	local = *(cPlayer**)(0x004E4DBC);
	pPlayerTable = *(cPlayerTable**)(0x004E4E08);
	for(;;)
	{
		if(GetAsyncKeyState(VK_LBUTTON) && *(int*)(0x004E4E10) > 0)
		{
			int target = target_cross();
			if(local->pos.z - pPlayerTable->player[target]->pos.z >= 7.5)
			{
				aim(pPlayerTable->player[target]->footpos, local->pos, local->yaw, local->pitch);
			}
			else
				aim(pPlayerTable->player[target]->pos, local->pos, local->yaw, local->pitch);
		}
	}
}

BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD dwReason, LPVOID lpReserved )
{
	if( dwReason == DLL_PROCESS_ATTACH )
	{
		CreateThread( NULL, NULL, (LPTHREAD_START_ROUTINE)aimbot, NULL, NULL, NULL);
	}
	return TRUE;
}

#include <math.h>

class cPlayer;
class cPlayerTable;
struct vec;

struct vec
{
    union
    {
        struct { float x, y, z; };
        float v[3];
        int i[3];
    };

    vec() {}
    vec(float a, float b, float c) : x(a), y(b), z(c) {}
    vec(float *v) : x(v[0]), y(v[1]), z(v[2]) {}

    float &operator[](int i)       { return v[i]; }
    float  operator[](int i) const { return v[i]; }

    bool iszero() const { return x==0 && y==0 && z==0; }

    bool operator==(const vec &o) const { return x == o.x && y == o.y && z == o.z; }
    bool operator!=(const vec &o) const { return x != o.x || y != o.y || z != o.z; }
    vec operator-() const { return vec(-x, -y, -z); }

    vec &mul(float f) { x *= f; y *= f; z *= f; return *this; }
    vec &div(float f) { x /= f; y /= f; z /= f; return *this; }
    vec &add(float f) { x += f; y += f; z += f; return *this; }
    vec &sub(float f) { x -= f; y -= f; z -= f; return *this; }

    vec &add(const vec &o) { x += o.x; y += o.y; z += o.z; return *this; }
    vec &sub(const vec &o) { x -= o.x; y -= o.y; z -= o.z; return *this; }

    float squaredlen() const { return x*x + y*y + z*z; }
    float dot(const vec &o) const { return x*o.x + y*o.y + z*o.z; }

    float magnitude() const { return sqrtf(squaredlen()); }
    vec &normalize() { div(magnitude()); return *this; }

    float dist(const vec &e) const { vec t; return dist(e, t); }
    float dist(const vec &e, vec &t) const { t = *this; t.sub(e); return t.magnitude(); }

    float distxy(const vec &e) const { float dx = e.x - x, dy = e.y - y; return sqrtf(dx*dx + dy*dy); }
    float magnitudexy() const { return sqrtf(x*x + y*y); }

    bool reject(const vec &o, float max) const { return x>o.x+max || x<o.x-max || y>o.y+max || y<o.y-max; }

    vec &cross(const vec &a, const vec &b) { x = a.y*b.z-a.z*b.y; y = a.z*b.x-a.x*b.z; z = a.x*b.y-a.y*b.x; return *this; }

    void rotate_around_z(float angle) { *this = vec(cosf(angle)*x-sinf(angle)*y, cosf(angle)*y+sinf(angle)*x, z); }
    void rotate_around_x(float angle) { *this = vec(x, cosf(angle)*y-sinf(angle)*z, cosf(angle)*z+sinf(angle)*y); }
    void rotate_around_y(float angle) { *this = vec(cosf(angle)*x-sinf(angle)*z, y, cosf(angle)*z+sinf(angle)*x); }

    vec &rotate(float angle, const vec &d)
    {
        float c = cosf(angle), s = sinf(angle);
        return rotate(c, s, d);
    }

    vec &rotate(float c, float s, const vec &d)
    {
        *this = vec(x*(d.x*d.x*(1-c)+c) + y*(d.x*d.y*(1-c)-d.z*s) + z*(d.x*d.z*(1-c)+d.y*s),
                    x*(d.y*d.x*(1-c)+d.z*s) + y*(d.y*d.y*(1-c)+c) + z*(d.y*d.z*(1-c)-d.x*s),
                    x*(d.x*d.z*(1-c)-d.y*s) + y*(d.y*d.z*(1-c)+d.x*s) + z*(d.z*d.z*(1-c)+c));
        return *this;
    }

    void orthogonal(const vec &d)
    {
        int i = fabs(d.x) > fabs(d.y) ? (fabs(d.x) > fabs(d.z) ? 0 : 2) : (fabs(d.y) > fabs(d.z) ? 1 : 2);
        v[i] = d[(i+1)%3];
        v[(i+1)%3] = -d[i];
        v[(i+2)%3] = 0;
    }
};

class cPlayer
{
public:
		char unknown0[4]; //0x0000
	vec pos;
		char unknown16[36]; //0x0010
	vec footpos;
	float yaw; //0x0040  
	float pitch; //0x0044  
};//Size=0x0228(552)


class cPlayerTable
{
public:
	char unknown0[4]; //0x0000
	cPlayer* player[32]; //0x0004  
};//Size=0x043C(1084)